removing old rospack
This commit is contained in:
Ken Conley
parent
e751889c44
commit
cf44a82c20
|
|
@ -1,7 +1,11 @@
|
|||
project(rosclean)
|
||||
find_package(catkin)
|
||||
|
||||
add_subdirectory(scripts)
|
||||
|
||||
install_cmake_infrastructure(${PROJECT_NAME}
|
||||
VERSION 0.0.1
|
||||
PYTHONPATH src
|
||||
)
|
||||
|
||||
enable_python(${PROJECT_NAME})
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
include $(shell rospack find mk)/cmake.mk
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
if(ROSBUILD)
|
||||
include(rosbuild.cmake)
|
||||
return()
|
||||
endif()
|
||||
# We can't use rosbuild/rosbuild.cmake here, because rosbuild.cmake
|
||||
# requires rospack, and we're in the process of building rospack.
|
||||
cmake_minimum_required(VERSION 2.4.6)
|
||||
set(CMAKE_BUILD_TYPE Release)
|
||||
|
||||
set(CMAKE_OSX_ARCHITECTURES "x86_64")
|
||||
|
||||
set(CMAKE_INSTALL_PREFIX /tmp/rospack)
|
||||
#set(CMAKE_INSTALL_RPATH_USE_LINK_RPATH true)
|
||||
#set(CMAKE_SKIP_BUILD_RPATH true)
|
||||
set(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")
|
||||
SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
|
||||
|
||||
include_directories(include ${PROJECT_SOURCE_DIR})
|
||||
|
||||
# Include the rosbuild's rosconfig.cmake, which includes logic for checking
|
||||
# for $ROS_ROOT/rosconfig.cmake, where the user may have adjusted the build
|
||||
# configuration. In particular, that's where static vs. shared is set.
|
||||
include($ENV{ROS_ROOT}/core/rosbuild/rosconfig.cmake)
|
||||
|
||||
add_definitions(-DTIXML_USE_STL)
|
||||
set(rospack_sources rospack.cpp
|
||||
tinyxml-2.5.3/tinystr.cpp
|
||||
tinyxml-2.5.3/tinyxml.cpp
|
||||
tinyxml-2.5.3/tinyxmlparser.cpp
|
||||
tinyxml-2.5.3/tinyxmlerror.cpp)
|
||||
set(rosstack_sources rosstack.cpp)
|
||||
|
||||
# Here we duplicate a bit of the logic in rosbuild/public.cmake.
|
||||
if(NOT ROS_BUILD_STATIC_LIBS AND NOT ROS_BUILD_SHARED_LIBS)
|
||||
message(FATAL_ERROR "Neither shared nor static libraries are enabled. Please set either ROS_BUILD_STATIC_LIBS or ROS_BUILD_SHARED_LIBS to true.")
|
||||
endif(NOT ROS_BUILD_STATIC_LIBS AND NOT ROS_BUILD_SHARED_LIBS)
|
||||
if(ROS_BUILD_STATIC_EXES AND ROS_BUILD_SHARED_LIBS)
|
||||
message(FATAL_ERROR "Static executables are requested, but so are shared libs. This configuration is unsupported. Please either set ROS_BUILD_SHARED_LIBS to false or set ROS_BUILD_STATIC_EXES to false.")
|
||||
endif(ROS_BUILD_STATIC_EXES AND ROS_BUILD_SHARED_LIBS)
|
||||
|
||||
if(ROS_BUILD_SHARED_LIBS)
|
||||
# If shared libs are being built, they get the default CMake target name
|
||||
# No matter what, the libraries get the same name in the end.
|
||||
add_library(rospack SHARED ${rospack_sources})
|
||||
add_library(rosstack SHARED ${rosstack_sources})
|
||||
|
||||
# Prevent deletion of existing lib of same name
|
||||
set_target_properties(rospack PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
set_target_properties(rosstack PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
endif(ROS_BUILD_SHARED_LIBS)
|
||||
|
||||
if(ROS_BUILD_STATIC_LIBS)
|
||||
add_definitions("-DROS_STATIC")
|
||||
# If we're only building static libs, then they get the default CMake
|
||||
# target name.
|
||||
if(NOT ROS_BUILD_SHARED_LIBS)
|
||||
set(static_rospack "rospack")
|
||||
set(static_rosstack "rosstack")
|
||||
else(NOT ROS_BUILD_SHARED_LIBS)
|
||||
set(static_rospack "rospack-static")
|
||||
set(static_rosstack "rosstack-static")
|
||||
endif(NOT ROS_BUILD_SHARED_LIBS)
|
||||
|
||||
add_library(${static_rospack} STATIC ${rospack_sources})
|
||||
add_library(${static_rosstack} STATIC ${rosstack_sources})
|
||||
|
||||
# Set output name to be the same as shared lib (may not work on Windows)
|
||||
set_target_properties(${static_rospack} PROPERTIES OUTPUT_NAME "rospack")
|
||||
set_target_properties(${static_rosstack} PROPERTIES OUTPUT_NAME "rosstack")
|
||||
# Also add -fPIC, because CMake leaves it out when building static
|
||||
# libs, even though it's necessary on 64-bit machines for linking this
|
||||
# lib against shared libs downstream.
|
||||
set_target_properties(${static_rospack} PROPERTIES COMPILE_FLAGS "-fPIC")
|
||||
set_target_properties(${static_rosstack} PROPERTIES COMPILE_FLAGS "-fPIC")
|
||||
|
||||
# Prevent deletion of existing lib of same name
|
||||
set_target_properties(${static_rospack} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
set_target_properties(${static_rosstack} PROPERTIES CLEAN_DIRECT_OUTPUT 1)
|
||||
endif(ROS_BUILD_STATIC_LIBS)
|
||||
|
||||
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
|
||||
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../../bin)
|
||||
|
||||
add_executable(rospackexe main.cpp)
|
||||
set_target_properties(rospackexe PROPERTIES OUTPUT_NAME rospack)
|
||||
target_link_libraries(rosstack rospack)
|
||||
add_executable(rosstackexe rosstack_main.cpp)
|
||||
set_target_properties(rosstackexe PROPERTIES OUTPUT_NAME rosstack)
|
||||
|
||||
target_link_libraries(rospackexe rospack)
|
||||
target_link_libraries(rosstackexe rosstack rospack)
|
||||
|
||||
if(ROS_BUILD_STATIC_EXES AND ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
|
||||
# This will probably only work on Linux. The LINK_SEARCH_END_STATIC
|
||||
# property should be sufficient, but it doesn't appear to work
|
||||
# properly.
|
||||
set_target_properties(rospackexe PROPERTIES
|
||||
LINK_FLAGS "-static-libgcc -Wl,-Bstatic")
|
||||
set_target_properties(rosstackexe PROPERTIES
|
||||
LINK_FLAGS "-static-libgcc -Wl,-Bstatic")
|
||||
endif(ROS_BUILD_STATIC_EXES AND ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
|
||||
|
||||
#install(TARGETS rospack rosstack rospackexe rosstackexe
|
||||
# RUNTIME DESTINATION bin
|
||||
# LIBRARY DESTINATION lib)
|
||||
#install(FILES include/rospack/rospack.h
|
||||
# DESTINATION include/rospack)
|
||||
|
||||
# Prevent warnings about duplicate definition of the targets mentioned
|
||||
# below
|
||||
if(COMMAND cmake_policy)
|
||||
# Logical target names must be globally unique.
|
||||
cmake_policy(SET CMP0002 OLD)
|
||||
endif(COMMAND cmake_policy)
|
||||
# These targets might be called by rosmakeall
|
||||
add_custom_target(test)
|
||||
add_custom_target(tests)
|
||||
add_custom_target(test-results)
|
||||
add_custom_target(test-future)
|
||||
add_custom_target(gcoverage)
|
||||
|
||||
#########################################
|
||||
# Uncomment below for new rospack
|
||||
#add_library(rp rp.cpp
|
||||
# tinyxml-2.5.3/tinyxml.cpp
|
||||
# tinyxml-2.5.3/tinyxmlparser.cpp
|
||||
# tinyxml-2.5.3/tinyxmlerror.cpp)
|
||||
#add_executable(rpexe rp_main.cpp)
|
||||
#set_target_properties(rpexe PROPERTIES OUTPUT_NAME rp)
|
||||
#target_link_libraries(rpexe rp boost_filesystem boost_system boost_program_options)
|
||||
#add_executable(rs rs_main.cpp)
|
||||
#target_link_libraries(rs rp boost_filesystem boost_system)
|
||||
# Uncomment above for new rospack
|
||||
#########################################
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
# Can't include cmake.mk because we need rospack to find it, and we're
|
||||
# trying to build rospack. So we inline a stripped-down version of
|
||||
# cmake.mk.
|
||||
#include $(shell rospack find mk)/cmake.mk
|
||||
|
||||
# The all target does the heavy lifting, creating the build directory and
|
||||
# invoking CMake
|
||||
all:
|
||||
@mkdir -p build
|
||||
-mkdir -p bin
|
||||
@if ! (cd build && cmake ..); then \
|
||||
echo "[rosbuild] CMake failed; trying to clean and start over"; \
|
||||
make clean; \
|
||||
mkdir -p build; \
|
||||
cd build && cmake ..; \
|
||||
fi
|
||||
cd build && make $(PARALLEL_JOBS)
|
||||
|
||||
install: all
|
||||
cd build && make install
|
||||
|
||||
# The clean target blows everything away
|
||||
clean:
|
||||
-cd build && make clean
|
||||
rm -rf build
|
||||
|
||||
test: all
|
||||
if cd build && make -k $@; then make test-results; else make test-results && exit 1; fi
|
||||
tests: all
|
||||
cd build && make $@
|
||||
test-future: all
|
||||
cd build && make -k $@
|
||||
gcoverage: all
|
||||
cd build && make $@
|
||||
|
||||
#SRC = main.cpp
|
||||
#LIBSRC = rospack.cpp \
|
||||
# tinyxml-2.5.3/tinystr.cpp \
|
||||
# tinyxml-2.5.3/tinyxml.cpp \
|
||||
# tinyxml-2.5.3/tinyxmlparser.cpp \
|
||||
# tinyxml-2.5.3/tinyxmlerror.cpp
|
||||
#
|
||||
#
|
||||
#OBJ = $(SRC:.cpp=.o)
|
||||
#LIBOBJ = $(LIBSRC:.cpp=.o)
|
||||
#OUT = ../../bin/rospack
|
||||
#LIBOUT = librospack.a
|
||||
#
|
||||
#CC=g++
|
||||
#AR=ar
|
||||
#LIBS=-lm
|
||||
#CFLAGS= -O3 -Wall -fPIC
|
||||
## For code coverage
|
||||
##LIBS=-lm -lgcov
|
||||
##CFLAGS= -O0 -Wall -g -fprofile-arcs -ftest-coverage
|
||||
#INCLUDES=-I.
|
||||
#
|
||||
#default: depend $(OUT) $(LIBOUT)
|
||||
#
|
||||
#$(OUT): $(OBJ) $(LIBOUT)
|
||||
# ${CC} $(OBJ) -o $(OUT) $(LIBS) -L. -lrospack
|
||||
#
|
||||
#$(LIBOUT): $(LIBOBJ)
|
||||
# ${AR} cr $@ $(LIBOBJ)
|
||||
#
|
||||
#.cpp.o:
|
||||
# ${CC} ${CFLAGS} ${INCLUDES} -c $< -o $@
|
||||
#
|
||||
#depend: $(SRC) $(LIBSRC)
|
||||
# gcc $(INCLUDES) -MM $(SRC) $(LIBSRC) >depend
|
||||
#
|
||||
#clean:
|
||||
# rm -f depend $(OBJ) $(OUT) $(LIBOUT) $(LIBOBJ)
|
||||
#
|
||||
#-include depend
|
||||
|
|
@ -1,364 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef ROSPACK_ROSPACK_H
|
||||
#define ROSPACK_ROSPACK_H
|
||||
|
||||
/* Author: Morgan Quigley, Brian Gerkey */
|
||||
|
||||
/**
|
||||
\mainpage
|
||||
\htmlinclude manifest.html
|
||||
|
||||
\section overview Overview
|
||||
|
||||
\b %rospack is the ROS package management tool. The %rospack package contains
|
||||
a single binary, called \b %rospack.
|
||||
|
||||
- Jump to \ref Usage "command-line usage".
|
||||
|
||||
%rospack is part dpkg, part pkg-config. The main function of %rospack is
|
||||
to crawl through the packages in ROS_ROOT and ROS_PACKAGE_PATH, read and
|
||||
parse the \b manifest.xml for each package, and assemble a complete
|
||||
dependency tree for all packages.
|
||||
|
||||
Using this tree, %rospack can answer a number of queries about packages and
|
||||
their dependencies. Common queries include:
|
||||
- find : return the absolute path to a package
|
||||
- depends : return a list of all of a package's dependencies
|
||||
- depends-on : return a list of packages that depend on the given package
|
||||
- export : return flags necessary for building and linking against a package
|
||||
|
||||
%rospack is intended to be cross-platform.
|
||||
|
||||
\subsection crawling Crawling algorithm
|
||||
%rospack crawls in the following order: the directory ROS_ROOT, followed by
|
||||
the colon-separated list of directories ROS_PACKAGE_PATH, in the order they
|
||||
are listed.
|
||||
|
||||
During the crawl, %rospack examines the contents of each directory, looking
|
||||
for a file called @b manifest.xml. If such a file is found, the directory
|
||||
containing it is considered to be a ROS package, with the package name
|
||||
equal to the directory name. The crawl does not descend further once a
|
||||
manifest is found (i.e., packages cannot be nested inside one another).
|
||||
|
||||
If a manifest.xml file is not found in a given directory, each subdirectory
|
||||
is searched. This subdirectory search is prevented if a file called @b
|
||||
rospack_nosubdirs is found. The directory itself is still searched for a
|
||||
manifest, but its subdirectories are not crawled.
|
||||
|
||||
If multiple packages by the same name exist within the search path, the
|
||||
first one found wins. It is strongly recommended that you keep packages by
|
||||
the same name in separate trees, each having its own element within
|
||||
ROS_PACKAGE_PATH. That way, you can deterministically control the search
|
||||
order by the way that you specify ROS_PACKAGE_PATH. The search order
|
||||
within a given element of ROS_PACKAGE_PATH can be unpredictably affected by
|
||||
the details of how files are laid out on disk.
|
||||
|
||||
\subsection efficiency Efficiency considerations
|
||||
%rospack re-parses the manifest.xml files and rebuilds the dependency tree
|
||||
on each execution. However, it maintains a cache of package directories in
|
||||
ROS_ROOT/.rospack_cache. This cache is updated whenever there is a cache
|
||||
miss, or when the cache is 60 seconds old. You can change this timeout by
|
||||
setting the environment variable ROS_CACHE_TIMEOUT, in seconds. Set it to
|
||||
0.0 to force a cache rebuild on every invocation of %rospack.
|
||||
|
||||
%rospack's performance can be adversely affected by the presence of very
|
||||
broad and/or deep directory structures that don't contain manifest files.
|
||||
If such directories are in %rospack's search path, it can spend a lot of
|
||||
time crawling them only to discover that there are no packages to be found.
|
||||
You can prevent this latency by creating a @b rospack_nosubdirs file in
|
||||
such directories. If rospack seems to be running annoyingly slowly, you
|
||||
can use the profile command, which will print out the 20 slowest trees
|
||||
to crawl (or use profile --length=N to print the slowest N trees).
|
||||
|
||||
\subsection dependencies No dependencies
|
||||
Because %rospack is the tool that determines dependencies, it cannot depend
|
||||
on anything else. Thus %rospack contains a copy of the TinyXML library,
|
||||
instead of using the copy available in 3rdparty. For the same reason, unit
|
||||
tests for %rospack, which require gtest, are in a separate package, called
|
||||
rospack_test.
|
||||
|
||||
\section codeapi Code API
|
||||
|
||||
%rospack is used entirely as a command-line tool. While the main
|
||||
functionality within %rospack is built as a library for testing purposes,
|
||||
it is not intended for use in writing other applications. Should this
|
||||
change, the %rospack library API should be cleaned up and better
|
||||
documented.
|
||||
|
||||
For now, the user-visible API is:
|
||||
- rospack::ROSPack::ROSPack()
|
||||
- rospack::ROSPack::run()
|
||||
|
||||
See main.cpp for example usage
|
||||
|
||||
\section rosapi ROS API
|
||||
%rospack does not expose a ROS API.
|
||||
|
||||
\section commandline Command-line tools
|
||||
|
||||
\subsection rospack rospack
|
||||
|
||||
%rospack is the command-line tool that provides package management services.
|
||||
|
||||
%rospack crawls the directory ROS_ROOT and the colon-separated directories
|
||||
in ROS_PACKAGE_PATH, determining a directory to be package if it contains a
|
||||
file called @b manifest.xml.
|
||||
|
||||
*/
|
||||
|
||||
#if defined(WIN32)
|
||||
#if defined(ROS_STATIC)
|
||||
#define ROSPACK_EXPORT
|
||||
#elif defined(rospack_EXPORTS)
|
||||
#define ROSPACK_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define ROSPACK_EXPORT __declspec(dllimport)
|
||||
#endif
|
||||
#else
|
||||
#define ROSPACK_EXPORT
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
|
||||
#include "tinyxml-2.5.3/tinyxml.h"
|
||||
|
||||
namespace rospack
|
||||
{
|
||||
|
||||
class Package;
|
||||
// global helper functions
|
||||
void string_split(const std::string &s, std::vector<std::string> &t, const std::string &d);
|
||||
bool file_exists(const std::string &fname);
|
||||
extern const char *fs_delim;
|
||||
Package *g_get_pkg(const std::string &name);
|
||||
|
||||
typedef std::vector<Package *> VecPkg;
|
||||
typedef std::list<Package*> Acc;
|
||||
typedef std::list<Acc> AccList;
|
||||
|
||||
/**
|
||||
* The Package class contains information about a single package
|
||||
*/
|
||||
class ROSPACK_EXPORT Package
|
||||
{
|
||||
public:
|
||||
enum traversal_order_t { POSTORDER, PREORDER };
|
||||
std::string name, path;
|
||||
// These will cause warnings on Windows when compiling the DLL because they
|
||||
// are static. They should more correctly be accessed via accessor functions
|
||||
// that are exported from the class, rather than directly, in order to
|
||||
// "prevent data corruption." Since main.cpp is currently the only known
|
||||
// client and it doesn't use them, I'm not caring about the warnings yet.
|
||||
static std::vector<Package *> pkgs;
|
||||
static std::vector<Package *> deleted_pkgs;
|
||||
|
||||
Package(std::string _path);
|
||||
static bool is_package(std::string path);
|
||||
static bool is_no_subdirs(std::string path);
|
||||
const VecPkg &deps1();
|
||||
const VecPkg &deps(traversal_order_t order, int depth=0);
|
||||
std::string manifest_path();
|
||||
std::string flags(std::string lang, std::string attrib);
|
||||
std::string rosdep();
|
||||
std::string versioncontrol();
|
||||
std::vector<std::pair<std::string, std::string> > plugins();
|
||||
VecPkg descendants1();
|
||||
const std::vector<Package *> &descendants(int depth=0);
|
||||
rospack_tinyxml::TiXmlElement *manifest_root();
|
||||
void accumulate_deps(AccList& acc_list, Package* to);
|
||||
|
||||
/**
|
||||
* \brief Returns the message flags for this package. If the path/msg or path/srv directories exist,
|
||||
* adds appropriate compile/link flags depending on what is requested
|
||||
* \param cflags Whether or not to include compile flags
|
||||
* \param lflags Whether or not to include link flags
|
||||
*/
|
||||
std::string cpp_message_flags(bool cflags, bool lflags);
|
||||
|
||||
|
||||
private:
|
||||
bool deps_calculated, direct_deps_calculated, descendants_calculated;
|
||||
std::vector<Package *> _deps, _direct_deps, _descendants;
|
||||
rospack_tinyxml::TiXmlDocument manifest;
|
||||
bool manifest_loaded;
|
||||
|
||||
Package(const Package &p) { } // just override the default public one
|
||||
|
||||
bool has_parent(std::string pkg);
|
||||
const std::vector<Package *> &direct_deps(bool missing_pkg_as_warning=false);
|
||||
std::string direct_flags(std::string lang, std::string attrib);
|
||||
void load_manifest();
|
||||
};
|
||||
|
||||
/**
|
||||
* The ROSPack class contains information the entire package dependency
|
||||
* tree.
|
||||
*/
|
||||
class ROSPACK_EXPORT ROSPack
|
||||
{
|
||||
public:
|
||||
static const char* usage();
|
||||
|
||||
char *ros_root;
|
||||
|
||||
ROSPack();
|
||||
|
||||
~ROSPack();
|
||||
|
||||
Package *get_pkg(std::string pkgname);
|
||||
|
||||
int cmd_depends_on(bool include_indirect);
|
||||
|
||||
int cmd_depends_why();
|
||||
|
||||
int cmd_find();
|
||||
|
||||
int cmd_deps();
|
||||
|
||||
int cmd_depsindent(Package* pkg, int indent);
|
||||
|
||||
int cmd_deps_manifests();
|
||||
int cmd_deps_msgsrv();
|
||||
|
||||
int cmd_deps1();
|
||||
|
||||
/*
|
||||
int cmd_predeps(char **args, int args_len);
|
||||
*/
|
||||
|
||||
std::string snarf_libs(std::string flags, bool invert=false);
|
||||
std::string snarf_flags(std::string flags, std::string token, bool invert=false);
|
||||
|
||||
int cmd_libs_only(std::string token);
|
||||
|
||||
int cmd_cflags_only(std::string token);
|
||||
|
||||
int cmd_make(char **args, int args_len);
|
||||
|
||||
void export_flags(std::string pkg, std::string lang, std::string attrib);
|
||||
|
||||
int cmd_versioncontrol(int depth);
|
||||
|
||||
int cmd_rosdep(int depth);
|
||||
|
||||
int cmd_export();
|
||||
|
||||
int cmd_plugins();
|
||||
|
||||
/** @brief The method that does the work.
|
||||
*
|
||||
* Call the run() method with argc and argv to crawl for packages, build
|
||||
* the tree, and answer the query in the command-line arguments.
|
||||
*
|
||||
* @throws std::runtime_error
|
||||
*/
|
||||
int run(int argc, char **argv);
|
||||
|
||||
// Another form of run, which takes the arguments as a single string.
|
||||
// WARNING: this method does naive string-splitting on spaces.
|
||||
int run(const std::string& cmd);
|
||||
|
||||
// Get the accumulated output
|
||||
std::string getOutput() { return output_acc; }
|
||||
|
||||
// is -q (quiet) provided ?
|
||||
bool is_quiet() { return opt_quiet; }
|
||||
|
||||
int cmd_print_package_list(bool print_path);
|
||||
|
||||
int cmd_list_duplicates();
|
||||
|
||||
int cmd_print_langs_list();
|
||||
|
||||
void crawl_for_packages(bool force_crawl = false);
|
||||
VecPkg partial_crawl(const std::string &path);
|
||||
|
||||
// Exposed for testing purposes only
|
||||
std::string deduplicate_tokens(const std::string& s);
|
||||
|
||||
// Storage for --foo options
|
||||
// --deps-only
|
||||
bool opt_deps_only;
|
||||
// --lang=
|
||||
std::string opt_lang;
|
||||
// --attrib=
|
||||
std::string opt_attrib;
|
||||
// --length=
|
||||
std::string opt_length;
|
||||
// --top=
|
||||
std::string opt_top;
|
||||
// The package name
|
||||
std::string opt_package;
|
||||
// --target=
|
||||
std::string opt_target;
|
||||
// the number of entries to list in the profile table
|
||||
int opt_profile_length;
|
||||
// only display zombie directories in profile?
|
||||
bool opt_profile_zombie_only;
|
||||
// display warnings about missing dependencies?
|
||||
bool opt_warn_on_missing_deps;
|
||||
// display pairs of duplicate packages?
|
||||
bool opt_display_duplicate_pkgs;
|
||||
|
||||
private:
|
||||
// is quiet
|
||||
bool opt_quiet;
|
||||
bool cache_lock_failed;
|
||||
bool crawled;
|
||||
std::string getCachePath();
|
||||
// Storage for list of path components, used in add_package. We keep it
|
||||
// here to avoid reallocation in every run of add_package.
|
||||
std::vector<std::string> path_components;
|
||||
// Add package, filtering out duplicates.
|
||||
Package* add_package(std::string path);
|
||||
/** tests if the cache exists, is new enough, and is valid */
|
||||
bool cache_is_good();
|
||||
/** returns a double representing the seconds since the Epoch */
|
||||
static double time_since_epoch();
|
||||
/** remove trailing slashes */
|
||||
void sanitize_rppvec(std::vector<std::string> &rppvec);
|
||||
// Output accumulates here
|
||||
std::string output_acc;
|
||||
// A place to store heap-allocated argv, in case we were passed a
|
||||
// std::string in run(). It'll be freed on destruction.
|
||||
int my_argc;
|
||||
char** my_argv;
|
||||
void freeArgv();
|
||||
// Total number of packages found, including duplicates. Used in
|
||||
// determining whether a directory is a zombie.
|
||||
int total_num_pkgs;
|
||||
// Were there any duplicate pkgs found in the crawl?
|
||||
bool duplicate_packages_found;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,161 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2009, Morgan Quigley, Brian Gerkey
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef ROSSTACK_ROSSTACK_H
|
||||
#define ROSSTACK_ROSSTACK_H
|
||||
|
||||
/* Author: Morgan Quigley, Brian Gerkey */
|
||||
|
||||
/**
|
||||
\mainpage
|
||||
\htmlinclude manifest.html
|
||||
|
||||
\section overview Overview
|
||||
|
||||
\b %rosstack is a ROS dependency and distribution tool. The %rosstack package contains
|
||||
a single binary, called \b %rosstack.
|
||||
*/
|
||||
|
||||
#if defined(WIN32)
|
||||
#if defined(ROS_STATIC)
|
||||
#define ROSSTACK_EXPORT
|
||||
#elif defined(rosstack_EXPORTS)
|
||||
#define ROSSTACK_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
#define ROSSTACK_EXPORT __declspec(dllimport)
|
||||
#endif
|
||||
#else
|
||||
#define ROSSTACK_EXPORT
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "tinyxml-2.5.3/tinyxml.h"
|
||||
#include "rospack/rospack.h"
|
||||
|
||||
namespace rosstack
|
||||
{
|
||||
|
||||
class ROSSTACK_EXPORT Stack;
|
||||
// global helper functions
|
||||
void string_split(const std::string &s, std::vector<std::string> &t, const std::string &d);
|
||||
bool file_exists(const std::string &fname);
|
||||
extern const char *fs_delim;
|
||||
extern const char *path_delim;
|
||||
Stack *g_get_stack(const std::string &name);
|
||||
typedef std::vector<Stack *> VecStack;
|
||||
|
||||
/**
|
||||
* The Stack class contains information about a single stack
|
||||
*/
|
||||
class ROSSTACK_EXPORT Stack
|
||||
{
|
||||
public:
|
||||
enum traversal_order_t { POSTORDER, PREORDER };
|
||||
std::string name, path;
|
||||
static std::vector<Stack *> stacks;
|
||||
|
||||
Stack(std::string _path);
|
||||
static bool is_stack(const std::string &path);
|
||||
static bool is_package(const std::string &path);
|
||||
static bool is_no_subdirs(const std::string &path);
|
||||
const VecStack &deps1();
|
||||
const VecStack &deps(traversal_order_t order, int depth=0);
|
||||
std::string manifest_path();
|
||||
VecStack descendants1();
|
||||
const VecStack &descendants(int depth=0);
|
||||
rospack_tinyxml::TiXmlElement *manifest_root();
|
||||
|
||||
private:
|
||||
bool deps_calculated, direct_deps_calculated, descendants_calculated;
|
||||
VecStack _deps, _direct_deps, _descendants;
|
||||
rospack_tinyxml::TiXmlDocument manifest;
|
||||
bool manifest_loaded;
|
||||
|
||||
Stack(const Stack &p) { } // just override the default public one
|
||||
|
||||
bool has_parent(std::string stk);
|
||||
const VecStack &direct_deps(bool missing_pkg_as_warning=false);
|
||||
void load_manifest();
|
||||
};
|
||||
|
||||
/**
|
||||
* The ROSStack class contains information the entire stack dependency
|
||||
* tree.
|
||||
*/
|
||||
class ROSSTACK_EXPORT ROSStack
|
||||
{
|
||||
public:
|
||||
static const char* usage();
|
||||
char *ros_root;
|
||||
rospack::ROSPack rp;
|
||||
|
||||
ROSStack();
|
||||
~ROSStack();
|
||||
Stack *get_stack(const std::string &name);
|
||||
int cmd_depends_on(bool include_indirect);
|
||||
int cmd_find();
|
||||
int cmd_contains();
|
||||
int cmd_contains_path();
|
||||
int cmd_deps();
|
||||
int cmd_depsindent(Stack* stk, int indent);
|
||||
int cmd_deps_manifests();
|
||||
int cmd_deps1();
|
||||
|
||||
/** @brief The method that does the work.
|
||||
*
|
||||
* Call the run() method with argc and argv to crawl for packages, build
|
||||
* the tree, and answer the query in the command-line arguments.
|
||||
*
|
||||
* @throws std::runtime_error
|
||||
*/
|
||||
int run(int argc, char **argv);
|
||||
|
||||
int cmd_print_stack_list(bool print_path);
|
||||
int cmd_print_packages();
|
||||
|
||||
void crawl_for_stacks(bool force_crawl = false);
|
||||
std::string lookup_owner(std::string pkg_name, bool just_owner_name);
|
||||
void deleteCache();
|
||||
private:
|
||||
bool crawled;
|
||||
/** tests if the cache exists, is new enough, and is valid */
|
||||
void createROSHomeDirectory();
|
||||
std::string getCachePath();
|
||||
// Add stack, filtering out duplicates.
|
||||
Stack* add_stack(std::string path);
|
||||
bool cache_is_good();
|
||||
/** returns a double representing the seconds since the Epoch */
|
||||
static double time_since_epoch();
|
||||
/** remove trailing slashes */
|
||||
void sanitize_rppvec(std::vector<std::string> &rppvec);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,98 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* Author: Morgan Quigley, Brian Gerkey */
|
||||
|
||||
|
||||
#include "rospack/rospack.h"
|
||||
|
||||
#include <stdexcept>
|
||||
#if !defined(WIN32)
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc <= 1)
|
||||
{
|
||||
fputs(rospack::ROSPack::usage(), stderr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if !defined(WIN32)
|
||||
// If it looks we're running under sudo, try to drop back to the normal
|
||||
// user, to avoid writing the cache with inappropriate permissions,
|
||||
// #2884.
|
||||
// Do the group first, because we can't do it after changing the user.
|
||||
char* sudo_gid_string = getenv("SUDO_GID");
|
||||
if(sudo_gid_string)
|
||||
{
|
||||
gid_t sudo_gid = (int)strtol(sudo_gid_string, (char **)NULL, 10);
|
||||
if(setgid(sudo_gid))
|
||||
perror("[rospack] Failed to change GID; cache permissions may need to be adjusted manually. setgid()");
|
||||
}
|
||||
char* sudo_uid_string = getenv("SUDO_UID");
|
||||
if(sudo_uid_string)
|
||||
{
|
||||
uid_t sudo_uid = (int)strtol(sudo_uid_string, (char **)NULL, 10);
|
||||
if(setuid(sudo_uid))
|
||||
perror("[rospack] Failed to change UID; cache permissions may need to be adjusted manually. setuid()");
|
||||
}
|
||||
#endif
|
||||
|
||||
int ret;
|
||||
bool quiet;
|
||||
try
|
||||
{
|
||||
// Declare ROSPack instance inside the try block because its
|
||||
// constructor can throw (e.g., when ROS_ROOT isn't set).
|
||||
rospack::ROSPack rp;
|
||||
// Separate try block for running the command, to allow for suppressing
|
||||
// error output when -q is given.
|
||||
try
|
||||
{
|
||||
ret = rp.run(argc, argv);
|
||||
printf("%s", rp.getOutput().c_str());
|
||||
}
|
||||
catch(std::runtime_error &e)
|
||||
{
|
||||
// Return code is -1 no matter what, but don't rethrow if we were
|
||||
// asked to be quiet.
|
||||
ret = -1;
|
||||
if(!rp.is_quiet())
|
||||
throw;
|
||||
}
|
||||
}
|
||||
catch(std::runtime_error &e)
|
||||
{
|
||||
fprintf(stderr, "[rospack] %s\n", e.what());
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
<package>
|
||||
<description brief="C++ implementation of the ROS package manager">
|
||||
|
||||
<p>
|
||||
rospack is a command-line program which provides many of the services of the *NIX
|
||||
pkg-config tool. It is used to find packages among the "forest" of code in a
|
||||
typical ROS distribution, calculate dependencies, mangle Makefiles, and in
|
||||
general promote peace and harmony in a ROS distribution.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
rospack uses the TinyXML parser, a zLib-licensed library which is available here:
|
||||
|
||||
<a href="http://tinyxml.sourceforge.net">http://tinyxml.sourceforge.net</a>
|
||||
</p>
|
||||
|
||||
</description>
|
||||
<author>Morgan Quigley, Brian Gerkey</author>
|
||||
<license>BSD</license>
|
||||
<review status="Doc reviewed" notes="2010-01-07, excludes rosstack"/>
|
||||
<export>
|
||||
<cpp cflags="-I${prefix} -I${prefix}/include" lflags="-L${prefix}/lib -Wl,-rpath,${prefix}/lib -lrospack -lrosstack"/>
|
||||
</export>
|
||||
<platform os="ubuntu" version="9.04"/>
|
||||
<platform os="ubuntu" version="9.10"/>
|
||||
<platform os="ubuntu" version="10.04"/>
|
||||
<platform os="macports" version="macports"/>
|
||||
<rosbuild2>
|
||||
<export>
|
||||
<include_dir>${rospack_SOURCE_DIR}/include</include_dir>
|
||||
<include_dir>${rospack_SOURCE_DIR}</include_dir>
|
||||
<lib>rospack</lib>
|
||||
</export>
|
||||
</rosbuild2>
|
||||
</package>
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
#! /usr/bin/env python
|
||||
|
||||
# Copyright (c) 2009, Willow Garage, Inc.
|
||||
# All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
# * Neither the name of Willow Garage, Inc. nor the names of its
|
||||
# contributors may be used to endorse or promote products derived from
|
||||
# this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
# Author Tully Foote tfoote@willowgarage.com
|
||||
|
||||
#from __future__ import with_statement
|
||||
|
||||
import os
|
||||
import re
|
||||
import distutils.version
|
||||
import sys, string
|
||||
import subprocess
|
||||
import getopt
|
||||
import roslib
|
||||
import roslib.rosenv
|
||||
|
||||
from math import sqrt
|
||||
from optparse import OptionParser
|
||||
|
||||
|
||||
def get_all_packages(stack_name):
|
||||
|
||||
try:
|
||||
# Check version, make postscript if too old to make pdf
|
||||
args = ["rosstack", "contents", stack_name]
|
||||
vstr, verr = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
|
||||
except subprocess.CalledProcessError:
|
||||
print >> sys.stderr, "failed to call [rosstack contents %s]"%stack_name
|
||||
return vstr.split()
|
||||
|
||||
|
||||
def mark_uninstalled(packages):
|
||||
print "uninstalling, ", packages
|
||||
for p in packages:
|
||||
filename = os.path.join(roslib.packages.get_pkg_dir(p), "ROS_NOBUILD")
|
||||
subprocess.check_call(["rm", filename])
|
||||
|
||||
def mark_installed(packages):
|
||||
print "installing ", packages
|
||||
for p in packages:
|
||||
filename = os.path.join(roslib.packages.get_pkg_dir(p), "ROS_NOBUILD")
|
||||
subprocess.check_call(["touch", filename])
|
||||
|
||||
def build_stack(packages):
|
||||
print "building ", packages
|
||||
args = ["rosmake"]
|
||||
args.extend( packages )
|
||||
subprocess.check_call(args)
|
||||
|
||||
|
||||
|
||||
def vdmain():
|
||||
parser = OptionParser(usage="usage: %prog [options] [stack1] ... [stackN]", prog='rxdeps')
|
||||
parser.add_option("-i", "--installed", dest="installed", default=False,
|
||||
action="store_true", help="Mark Packages as installed")
|
||||
parser.add_option("-u", "--uninstalled", dest="uninstalled", default=False,
|
||||
action="store_true", help="Unmark packages as installed")
|
||||
parser.add_option("-b", "--build", dest="build", default=False,
|
||||
action="store_true", help="Build all packages in stack")
|
||||
parser.add_option("--stack_string", dest="stack_string", default=None,
|
||||
action="store", help="stack name (DEPRECATED)")
|
||||
parser.add_option("--stack_name", dest="stack_name", default=None,
|
||||
action="store", help="stack name(DEPRECATED)")
|
||||
parser.add_option("--stack_version", dest="stack_version", default=None,
|
||||
action="store", help="stack version(DEPRECATED)")
|
||||
|
||||
options, args = parser.parse_args()
|
||||
|
||||
if options.stack_name:
|
||||
args.append(options.stack_name)
|
||||
print "WARNING: --stack_name deprecated use arguments!"
|
||||
if options.stack_string:
|
||||
args.append(options.stack_string)
|
||||
print "WARNING: --stack_string deprecated use arguments!"
|
||||
if options.stack_version:
|
||||
print "WARNING: Stack version not used!"
|
||||
|
||||
packages = []
|
||||
for s in args:
|
||||
packages.extend(get_all_packages(s))
|
||||
|
||||
if options.build:
|
||||
build_stack(packages)
|
||||
|
||||
if options.installed:
|
||||
mark_installed(packages)
|
||||
|
||||
elif options.uninstalled:
|
||||
mark_uninstalled(packages)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
vdmain()
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import os, sys
|
||||
from optparse import OptionParser
|
||||
|
||||
NAME = 'rosalldeps'
|
||||
|
||||
# Taken from
|
||||
# http://mail.python.org/pipermail/python-list/2005-November/352658.html
|
||||
def remove_dups(L):
|
||||
"""Removes duplicate items from list L in place."""
|
||||
# Work backwards from the end of the list.
|
||||
for i in range(len(L)-1, -1, -1):
|
||||
# Check to see if the current item exists elsewhere in
|
||||
# the list, and if it does, delete it.
|
||||
if L[i] in L[:i]:
|
||||
del L[i]
|
||||
|
||||
def go(pkg, height):
|
||||
children = os.popen('rospack deps ' + pkg).readlines()
|
||||
if height == -1:
|
||||
parents = os.popen('rospack depends-on ' + pkg).readlines()
|
||||
elif height == 1:
|
||||
parents = os.popen('rospack depends-on1 ' + pkg).readlines()
|
||||
|
||||
siblings = []
|
||||
|
||||
for p in parents:
|
||||
siblings.extend(os.popen('rospack deps ' + p))
|
||||
|
||||
alldeps = []
|
||||
|
||||
alldeps.extend(children)
|
||||
alldeps.extend(siblings)
|
||||
alldeps.extend([pkg])
|
||||
alldeps.extend(parents)
|
||||
|
||||
remove_dups(alldeps)
|
||||
|
||||
for d in alldeps:
|
||||
dir = os.popen('rospack find ' + d).readlines()[0].strip()
|
||||
if os.path.exists(os.path.join(dir,'ROS_BUILD_BLACKLIST')) or \
|
||||
os.path.exists(os.path.join(dir,'ROS_NOBUILD')) or \
|
||||
not os.path.exists(os.path.join(dir,'Makefile')):
|
||||
continue
|
||||
else:
|
||||
print d.strip()
|
||||
|
||||
if __name__ == '__main__':
|
||||
parser = OptionParser(usage="usage: %prog [options] <pkg>", prog=NAME)
|
||||
parser.add_option("-H", "--height",
|
||||
dest="height", default=None,
|
||||
help="Limit maximum height of depends-on build (either 1 or -1)")
|
||||
(options, args) = parser.parse_args(sys.argv)
|
||||
|
||||
if len(args) != 2:
|
||||
parser.error('package must be specified')
|
||||
|
||||
pkg = args[1]
|
||||
height = -1
|
||||
if options.height:
|
||||
height = int(options.height)
|
||||
if height != 1 and height != -1:
|
||||
parser.error('height must be 1 or -1')
|
||||
|
||||
go(pkg, height)
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
USAGE = 'USAGE: rosallpkgs [pkg1 pkg2...]'
|
||||
|
||||
# Taken from
|
||||
# http://mail.python.org/pipermail/python-list/2005-November/352658.html
|
||||
def remove_dups(L):
|
||||
"""Removes duplicate items from list L in place."""
|
||||
# Work backwards from the end of the list.
|
||||
for i in range(len(L)-1, -1, -1):
|
||||
# Check to see if the current item exists elsewhere in
|
||||
# the list, and if it does, delete it.
|
||||
if L[i] in L[:i]:
|
||||
del L[i]
|
||||
|
||||
import os, sys
|
||||
|
||||
if len(sys.argv) > 1:
|
||||
pkgs = sys.argv[1:]
|
||||
else:
|
||||
pkgs = os.popen('rospack list-names').readlines()
|
||||
|
||||
alldeps = []
|
||||
for pkg in pkgs:
|
||||
children = os.popen('rospack deps ' + pkg).readlines()
|
||||
alldeps.extend(children)
|
||||
alldeps.extend([pkg])
|
||||
|
||||
remove_dups(alldeps)
|
||||
|
||||
for d in alldeps:
|
||||
print d.strip()
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
include(${CMAKE_CURRENT_BINARY_DIR}/package.cmake)
|
||||
|
||||
include_directories(include ${PROJECT_SOURCE_DIR})
|
||||
|
||||
add_definitions(-DTIXML_USE_STL)
|
||||
if(ROS_BUILD_STATIC_LIBS)
|
||||
add_definitions("-DROS_STATIC")
|
||||
endif()
|
||||
|
||||
set(rospack_sources rospack.cpp
|
||||
tinyxml-2.5.3/tinystr.cpp
|
||||
tinyxml-2.5.3/tinyxml.cpp
|
||||
tinyxml-2.5.3/tinyxmlparser.cpp
|
||||
tinyxml-2.5.3/tinyxmlerror.cpp)
|
||||
|
||||
set(rosstack_sources rosstack.cpp)
|
||||
|
||||
rosbuild_add_library(rospack ${rospack_sources})
|
||||
rosbuild_add_library(rosstack ${rosstack_sources})
|
||||
|
||||
rosbuild_add_executable(rospackexe main.cpp)
|
||||
set_target_properties(rospackexe PROPERTIES OUTPUT_NAME rospack)
|
||||
target_link_libraries(rosstack rospack)
|
||||
|
||||
rosbuild_add_executable(rosstackexe rosstack_main.cpp)
|
||||
set_target_properties(rosstackexe PROPERTIES OUTPUT_NAME rosstack)
|
||||
target_link_libraries(rospackexe rospack)
|
||||
target_link_libraries(rosstackexe rosstack rospack)
|
||||
|
||||
install(TARGETS rospack rosstack rospackexe rosstackexe
|
||||
RUNTIME DESTINATION bin
|
||||
LIBRARY DESTINATION lib
|
||||
ARCHIVE DESTINATION lib)
|
||||
|
||||
install(FILES include/rospack/rospack.h
|
||||
DESTINATION include/rospack)
|
||||
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
pkgs=`rospack list-names`
|
||||
|
||||
vcs=
|
||||
for p in $pkgs; do
|
||||
vc=`rospack vcs0 $p | sed 's/type: svn.*url: \([ ]*\)/\1/g'`
|
||||
for v in $vc; do
|
||||
vcs+=$v
|
||||
vcs+=' '
|
||||
done
|
||||
done
|
||||
|
||||
for v in $vcs; do
|
||||
if ! (echo p | svn info $v); then
|
||||
echo "Warning: failed to cache certificate for $v"
|
||||
fi
|
||||
done
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,33 +0,0 @@
|
|||
#!/bin/sh
|
||||
|
||||
# Case-insentive search through all manifests for a term. Returns
|
||||
# newline-separated list of names of packages that match the search term
|
||||
|
||||
USAGE="USAGE: rossearch <term>"
|
||||
|
||||
if [ $# != 1 ]; then
|
||||
echo $USAGE
|
||||
exit -1
|
||||
fi
|
||||
|
||||
term=$1
|
||||
|
||||
pkgdirs=`rospack list | awk {'print \$2'}`
|
||||
|
||||
manifests=""
|
||||
for d in $pkgdirs; do
|
||||
mnf="$d/manifest.xml"
|
||||
if [ ! -f $mnf ]; then
|
||||
echo "Missing manifest in $d!"
|
||||
else
|
||||
manifests="$manifests $mnf"
|
||||
fi
|
||||
done
|
||||
|
||||
grepresult=`grep -il "$term" $manifests`
|
||||
|
||||
for g in $grepresult; do
|
||||
d=`dirname $g`
|
||||
p=`basename $d`
|
||||
echo $p
|
||||
done
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,51 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2009, Morgan Quigley, Brian Gerkey
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/* Author: Morgan Quigley, Brian Gerkey */
|
||||
|
||||
|
||||
#include <stdexcept>
|
||||
#include "rospack/rosstack.h"
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
if (argc <= 1)
|
||||
return (fputs(rosstack::ROSStack::usage(), stderr) < 0);
|
||||
int ret;
|
||||
try
|
||||
{
|
||||
rosstack::ROSStack rs;
|
||||
ret = rs.run(argc, argv);
|
||||
}
|
||||
catch(std::runtime_error &e)
|
||||
{
|
||||
fprintf(stderr, "[rosstack] %s\n", e.what());
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
1450
tools/rospack/rp.cpp
1450
tools/rospack/rp.cpp
File diff suppressed because it is too large
Load Diff
|
|
@ -1,168 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2008, Willow Garage, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef ROSPACK_ROSPACK_H
|
||||
#define ROSPACK_ROSPACK_H
|
||||
|
||||
#include <boost/tr1/unordered_set.hpp>
|
||||
#include <boost/tr1/unordered_map.hpp>
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace rospack
|
||||
{
|
||||
|
||||
typedef enum
|
||||
{
|
||||
CRAWL_UP,
|
||||
CRAWL_DOWN
|
||||
} crawl_direction_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
POSTORDER,
|
||||
PREORDER
|
||||
} traversal_order_t;
|
||||
|
||||
class Stackage;
|
||||
class DirectoryCrawlRecord;
|
||||
|
||||
class Rosstackage
|
||||
{
|
||||
private:
|
||||
std::string manifest_name_;
|
||||
std::string cache_name_;
|
||||
crawl_direction_t crawl_dir_;
|
||||
|
||||
bool crawled_;
|
||||
std::tr1::unordered_set<std::string> dups_;
|
||||
void addStackage(const std::string& path);
|
||||
void crawlDetail(const std::string& path,
|
||||
bool force,
|
||||
int depth,
|
||||
bool collect_profile_data,
|
||||
std::vector<DirectoryCrawlRecord*>& profile_data,
|
||||
std::tr1::unordered_set<std::string>& profile_hash);
|
||||
bool dependsOnDetail(const std::string& name, bool direct,
|
||||
std::vector<Stackage*>& deps);
|
||||
bool depsDetail(const std::string& name, bool direct,
|
||||
std::vector<Stackage*>& deps);
|
||||
bool isStackage(const std::string& path);
|
||||
void loadManifest(Stackage* stackage);
|
||||
void computeDeps(Stackage* stackage, bool ignore_errors=false);
|
||||
void gatherDeps(Stackage* stackage, bool direct,
|
||||
traversal_order_t order,
|
||||
std::vector<Stackage*>& deps);
|
||||
void gatherDepsFull(Stackage* stackage, bool direct,
|
||||
traversal_order_t order, int depth,
|
||||
std::tr1::unordered_set<Stackage*>& deps_hash,
|
||||
std::vector<Stackage*>& deps,
|
||||
bool get_indented_deps,
|
||||
std::vector<std::string>& indented_deps);
|
||||
std::string getCachePath();
|
||||
bool readCache();
|
||||
void writeCache();
|
||||
bool validateCache();
|
||||
bool expandExportString(Stackage* stackage,
|
||||
const std::string& instring,
|
||||
std::string& outstring);
|
||||
|
||||
protected:
|
||||
std::tr1::unordered_map<std::string, Stackage*> stackages_;
|
||||
void crawl(const std::vector<std::string>& search_path, bool force);
|
||||
bool inStackage(std::string& name);
|
||||
|
||||
public:
|
||||
Rosstackage(std::string manifest_name,
|
||||
std::string cache_name,
|
||||
crawl_direction_t crawl_dir,
|
||||
bool quiet);
|
||||
virtual ~Rosstackage();
|
||||
|
||||
bool find(const std::string& name, std::string& path);
|
||||
void list(std::vector<std::pair<std::string, std::string> >& list);
|
||||
void listDuplicates(std::vector<std::string>& dups);
|
||||
bool deps(const std::string& name, bool direct, std::vector<std::string>& deps);
|
||||
bool dependsOn(const std::string& name, bool direct,
|
||||
std::vector<std::string>& deps);
|
||||
bool depsManifests(const std::string& name, bool direct,
|
||||
std::vector<std::string>& manifests);
|
||||
bool depsMsgSrv(const std::string& name, bool direct,
|
||||
std::vector<std::string>& gens);
|
||||
bool depsIndent(const std::string& name, bool direct,
|
||||
std::vector<std::string>& deps);
|
||||
bool rosdeps(const std::string& name, bool direct,
|
||||
std::vector<std::string>& rosdeps);
|
||||
bool vcs(const std::string& name, bool direct,
|
||||
std::vector<std::string>& vcs);
|
||||
bool exports(const std::string& name, const std::string& lang,
|
||||
const std::string& attrib, bool deps_only,
|
||||
std::vector<std::string>& flags);
|
||||
bool plugins(const std::string& name, const std::string& attrib,
|
||||
const std::string& top,
|
||||
std::vector<std::string>& flags);
|
||||
bool profile(const std::vector<std::string>& search_path,
|
||||
bool zombie_only,
|
||||
int length,
|
||||
std::vector<std::string>& dirs);
|
||||
};
|
||||
|
||||
class Rospack : public Rosstackage
|
||||
{
|
||||
public:
|
||||
Rospack(bool quiet=false);
|
||||
void crawl(const std::vector<std::string>& search_path,
|
||||
bool force);
|
||||
bool inPackage(std::string& name);
|
||||
};
|
||||
|
||||
class Rosstack : public Rosstackage
|
||||
{
|
||||
public:
|
||||
Rosstack(bool quiet=false);
|
||||
void crawl(const std::vector<std::string>& search_path,
|
||||
bool force);
|
||||
bool inStack(std::string& name);
|
||||
};
|
||||
|
||||
bool get_search_path_from_env(std::vector<std::string>& sp);
|
||||
|
||||
// Simple console output helpers
|
||||
void log_warn(const std::string& name,
|
||||
const std::string& msg,
|
||||
bool append_errno = false);
|
||||
void log_error(const std::string& name,
|
||||
const std::string& msg,
|
||||
bool append_errno = false);
|
||||
|
||||
} // namespace rospack
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,785 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2008, Willow Garage, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "rp.h"
|
||||
#include <boost/program_options.hpp>
|
||||
#include <boost/algorithm/string.hpp>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
namespace po = boost::program_options;
|
||||
|
||||
const char* usage();
|
||||
bool parse_args(int argc, char** argv, po::variables_map& vm);
|
||||
void parse_compiler_flags(const std::string& instring,
|
||||
const std::string& token,
|
||||
bool select,
|
||||
bool last,
|
||||
std::string& outstring);
|
||||
void deduplicate_tokens(const std::string& instring,
|
||||
bool last,
|
||||
std::string& outstring);
|
||||
|
||||
int
|
||||
main(int argc, char** argv)
|
||||
{
|
||||
po::variables_map vm;
|
||||
|
||||
if(!parse_args(argc, argv, vm))
|
||||
return 1;
|
||||
|
||||
bool quiet = (vm.count("quiet")==1);
|
||||
rospack::Rospack rp(quiet);
|
||||
|
||||
std::string command;
|
||||
std::string package;
|
||||
bool package_given = false;
|
||||
bool deps_only = false;
|
||||
std::string lang;
|
||||
std::string attrib;
|
||||
std::string top;
|
||||
std::string target;
|
||||
bool zombie_only = false;
|
||||
std::string length_str;
|
||||
int length;
|
||||
if(vm.count("command"))
|
||||
command = vm["command"].as<std::string>();
|
||||
if(!command.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no command given. Try 'rospack help'");
|
||||
return 0;
|
||||
}
|
||||
// For some commands, we force a crawl. Definitely anything that does a
|
||||
// depends-on calculation.
|
||||
bool force = false;
|
||||
if((command == "profile") ||
|
||||
(command == "depends-on") ||
|
||||
(command == "depends-on1") ||
|
||||
(command == "langs") ||
|
||||
(command == "list-duplicates"))
|
||||
force = true;
|
||||
std::vector<std::string> search_path;
|
||||
if(!rospack::get_search_path_from_env(search_path))
|
||||
return 1;
|
||||
|
||||
if(vm.count("package"))
|
||||
{
|
||||
package = vm["package"].as<std::string>();
|
||||
package_given = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// try to determine package from directory context
|
||||
rp.inPackage(package);
|
||||
}
|
||||
if(vm.count("deps-only"))
|
||||
deps_only = true;
|
||||
if(vm.count("lang"))
|
||||
lang = vm["lang"].as<std::string>();
|
||||
if(vm.count("attrib"))
|
||||
attrib = vm["attrib"].as<std::string>();
|
||||
if(vm.count("top"))
|
||||
top = vm["top"].as<std::string>();
|
||||
if(vm.count("target"))
|
||||
target = vm["target"].as<std::string>();
|
||||
if(vm.count("zombie-only"))
|
||||
zombie_only = true;
|
||||
if(vm.count("length"))
|
||||
{
|
||||
length_str = vm["length"].as<std::string>();
|
||||
length = atoi(length_str.c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
if(zombie_only)
|
||||
length = -1;
|
||||
else
|
||||
length = 20;
|
||||
}
|
||||
|
||||
// COMMAND: profile
|
||||
if(command == "profile")
|
||||
{
|
||||
if(package_given || target.size() || top.size() ||
|
||||
deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> dirs;
|
||||
if(rp.profile(search_path, zombie_only, length, dirs))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = dirs.begin();
|
||||
it != dirs.end();
|
||||
++it)
|
||||
printf("%s\n", (*it).c_str());
|
||||
return 0;
|
||||
}
|
||||
|
||||
// We crawl here because profile (above) does its own special crawl.
|
||||
rp.crawl(search_path, force);
|
||||
|
||||
// COMMAND: find [package]
|
||||
if(command == "find")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::string path;
|
||||
if(!rp.find(package, path))
|
||||
return 1;
|
||||
printf("%s\n", path.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: list
|
||||
else if(command == "list")
|
||||
{
|
||||
if(package_given || target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::pair<std::string, std::string> > list;
|
||||
rp.list(list);
|
||||
for(std::vector<std::pair<std::string, std::string> >::const_iterator it = list.begin();
|
||||
it != list.end();
|
||||
++it)
|
||||
{
|
||||
printf("%s %s\n", it->first.c_str(), it->second.c_str());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: list-names
|
||||
else if(command == "list-names")
|
||||
{
|
||||
if(package_given || target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::pair<std::string, std::string> > list;
|
||||
rp.list(list);
|
||||
for(std::vector<std::pair<std::string, std::string> >::const_iterator it = list.begin();
|
||||
it != list.end();
|
||||
++it)
|
||||
{
|
||||
printf("%s\n", it->first.c_str());
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: list-duplicates
|
||||
else if(command == "list-duplicates")
|
||||
{
|
||||
if(package_given || target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> dups;
|
||||
rp.listDuplicates(dups);
|
||||
// list-duplicates returns 0 if no duplicates
|
||||
if(!dups.size())
|
||||
return 0;
|
||||
// if there are dups, list-duplicates prints them and returns non-zero
|
||||
for(std::vector<std::string>::const_iterator it = dups.begin();
|
||||
it != dups.end();
|
||||
++it)
|
||||
{
|
||||
printf("%s\n", (*it).c_str());
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
// COMMAND: langs
|
||||
else if(command == "langs")
|
||||
{
|
||||
if(package_given || target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> deps;
|
||||
if(!rp.dependsOn("roslang", true, deps))
|
||||
return 1;
|
||||
const char* ros_lang_disable;
|
||||
if((ros_lang_disable = getenv("ROS_LANG_DISABLE")))
|
||||
{
|
||||
std::vector<std::string> disable_langs;
|
||||
boost::split(disable_langs, ros_lang_disable,
|
||||
boost::is_any_of(":"),
|
||||
boost::token_compress_on);
|
||||
std::vector<std::string>::iterator it = deps.begin();
|
||||
while(it != deps.end())
|
||||
{
|
||||
if(std::find(disable_langs.begin(), disable_langs.end(), *it) !=
|
||||
disable_langs.end())
|
||||
it = deps.erase(it);
|
||||
else
|
||||
++it;
|
||||
}
|
||||
}
|
||||
for(std::vector<std::string>::const_iterator it = deps.begin();
|
||||
it != deps.end();
|
||||
++it)
|
||||
printf("%s ", it->c_str());
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: depends [package] (alias: deps)
|
||||
else if(command == "depends" || command == "deps" ||
|
||||
command == "depends1" || command == "deps1")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> deps;
|
||||
if(!rp.deps(package, (command == "depends1" || command == "deps1"), deps))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = deps.begin();
|
||||
it != deps.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: depends-manifests [package] (alias: deps-manifests)
|
||||
else if(command == "depends-manifests" || command == "deps-manifests")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> manifests;
|
||||
if(!rp.depsManifests(package, false, manifests))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = manifests.begin();
|
||||
it != manifests.end();
|
||||
++it)
|
||||
printf("%s ", it->c_str());
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: depends-msgsrv [package] (alias: deps-msgsrv)
|
||||
else if(command == "depends-msgsrv" || command == "deps-msgsrv")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> gens;
|
||||
if(!rp.depsMsgSrv(package, false, gens))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = gens.begin();
|
||||
it != gens.end();
|
||||
++it)
|
||||
printf("%s ", it->c_str());
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: depends-indent [package] (alias: deps-indent)
|
||||
else if(command == "depends-indent" || command == "deps-indent")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> deps;
|
||||
if(!rp.depsIndent(package, false, deps))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = deps.begin();
|
||||
it != deps.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: rosdep [package] (alias: rosdeps)
|
||||
// COMMAND: rosdep0 [package] (alias: rosdeps0)
|
||||
else if(command == "rosdep" || command == "rosdeps" ||
|
||||
command == "rosdep0" || command == "rosdeps0")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> rosdeps;
|
||||
if(!rp.rosdeps(package, (command == "rosdep0" || command == "rosdeps0"), rosdeps))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = rosdeps.begin();
|
||||
it != rosdeps.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: vcs [package]
|
||||
// COMMAND: vcs0 [package]
|
||||
else if(command == "vcs" || command == "vcs0")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> vcs;
|
||||
if(!rp.vcs(package, (command == "vcs0"), vcs))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = vcs.begin();
|
||||
it != vcs.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: depends-on [package]
|
||||
// COMMAND: depends-on1 [package]
|
||||
else if(command == "depends-on" || command == "depends-on1")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> deps;
|
||||
if(!rp.dependsOn(package, (command == "depends-on1"), deps))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = deps.begin();
|
||||
it != deps.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: export [--deps-only] --lang=<lang> --attrib=<attrib> [package]
|
||||
else if(command == "export")
|
||||
{
|
||||
if(!package.size() || !lang.size() || !attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package / lang / attrib given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, lang, attrib, deps_only, flags))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
printf("%s ", it->c_str());
|
||||
printf("\n");
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: plugins --attrib=<attrib> [--top=<toppkg>] [package]
|
||||
else if(command == "plugins")
|
||||
{
|
||||
if(!package.size() || !attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package / attrib given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.plugins(package, attrib, top, flags))
|
||||
return 1;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
printf("%s\n", it->c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: cflags-only-I [--deps-only] [package]
|
||||
else if(command == "cflags-only-I")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, "cpp", "cflags", deps_only, flags))
|
||||
return 1;
|
||||
std::string combined;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
combined.append(*it + " ");
|
||||
std::string result;
|
||||
parse_compiler_flags(combined, "-I", true, false, result);
|
||||
printf("%s\n", result.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: cflags-only-other [--deps-only] [package]
|
||||
else if(command == "cflags-only-other")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, "cpp", "cflags", deps_only, flags))
|
||||
return 1;
|
||||
std::string combined;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
combined.append(*it + " ");
|
||||
std::string result;
|
||||
parse_compiler_flags(combined, "-I", false, false, result);
|
||||
printf("%s\n", result.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: libs-only-L [--deps-only] [package]
|
||||
else if(command == "libs-only-L")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, "cpp", "lflags", deps_only, flags))
|
||||
return 1;
|
||||
std::string combined;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
combined.append(*it + " ");
|
||||
std::string result;
|
||||
parse_compiler_flags(combined, "-L", true, false, result);
|
||||
printf("%s\n", result.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: libs-only-l [--deps-only] [package]
|
||||
else if(command == "libs-only-l")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, "cpp", "lflags", deps_only, flags))
|
||||
return 1;
|
||||
std::string combined;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
combined.append(*it + " ");
|
||||
std::string result;
|
||||
parse_compiler_flags(combined, "-l", true, true, result);
|
||||
printf("%s\n", result.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: libs-only-other [--deps-only] [package]
|
||||
else if(command == "libs-only-other")
|
||||
{
|
||||
if(!package.size())
|
||||
{
|
||||
rospack::log_error("rospack", "no package given");
|
||||
return 1;
|
||||
}
|
||||
if(target.size() || top.size() || length_str.size() || zombie_only)
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
std::vector<std::string> flags;
|
||||
if(!rp.exports(package, "cpp", "lflags", deps_only, flags))
|
||||
return 1;
|
||||
std::string combined;
|
||||
for(std::vector<std::string>::const_iterator it = flags.begin();
|
||||
it != flags.end();
|
||||
++it)
|
||||
combined.append(*it + " ");
|
||||
std::string intermediate;
|
||||
parse_compiler_flags(combined, "-L", false, false, intermediate);
|
||||
std::string result;
|
||||
parse_compiler_flags(intermediate, "-l", false, false, result);
|
||||
printf("%s\n", result.c_str());
|
||||
return 0;
|
||||
}
|
||||
// COMMAND: help
|
||||
else if(command == "help")
|
||||
{
|
||||
if(package_given || top.size() || length_str.size() ||
|
||||
zombie_only || deps_only || lang.size() || attrib.size())
|
||||
{
|
||||
rospack::log_error("rospack", "invalid option(s) given");
|
||||
return 1;
|
||||
}
|
||||
printf("%s", usage());
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
rospack::log_error("rospack",
|
||||
std::string("command ") + command + " not implemented");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
deduplicate_tokens(const std::string& instring,
|
||||
bool last,
|
||||
std::string& outstring)
|
||||
{
|
||||
std::vector<std::string> vec;
|
||||
std::tr1::unordered_set<std::string> set;
|
||||
boost::split(vec, instring,
|
||||
boost::is_any_of("\t "),
|
||||
boost::token_compress_on);
|
||||
if(last)
|
||||
std::reverse(vec.begin(), vec.end());
|
||||
std::vector<std::string> vec_out;
|
||||
vec_out.resize(vec.size());
|
||||
int i = 0;
|
||||
for(std::vector<std::string>::const_iterator it = vec.begin();
|
||||
it != vec.end();
|
||||
++it)
|
||||
{
|
||||
if(set.find(*it) == set.end())
|
||||
{
|
||||
vec_out[i] = *it;
|
||||
set.insert(*it);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if(last)
|
||||
std::reverse(vec_out.begin(), vec_out.end());
|
||||
for(std::vector<std::string>::const_iterator it = vec_out.begin();
|
||||
it != vec_out.end();
|
||||
++it)
|
||||
outstring.append(*it + " ");
|
||||
}
|
||||
|
||||
void
|
||||
parse_compiler_flags(const std::string& instring,
|
||||
const std::string& token,
|
||||
bool select,
|
||||
bool last,
|
||||
std::string& outstring)
|
||||
{
|
||||
std::string intermediate;
|
||||
std::vector<std::string> result_vec;
|
||||
boost::split(result_vec, instring,
|
||||
boost::is_any_of("\t "),
|
||||
boost::token_compress_on);
|
||||
for(std::vector<std::string>::const_iterator it = result_vec.begin();
|
||||
it != result_vec.end();
|
||||
++it)
|
||||
{
|
||||
// Combined into one arg
|
||||
if(it->size() > token.size() && it->substr(0,token.size()) == token)
|
||||
{
|
||||
if(select)
|
||||
intermediate.append(it->substr(token.size()) + " ");
|
||||
}
|
||||
// Space-separated
|
||||
else if((*it) == token)
|
||||
{
|
||||
std::vector<std::string>::const_iterator iit = it;
|
||||
if(++iit != result_vec.end())
|
||||
{
|
||||
if(it->size() >= token.size() && it->substr(0,token.size()) == token)
|
||||
{
|
||||
// skip it
|
||||
}
|
||||
else
|
||||
{
|
||||
if(select)
|
||||
intermediate.append((*iit) + " ");
|
||||
it = iit;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Special case: if we're told to look for -l, then also find *.a
|
||||
else if(it->size() > 2 &&
|
||||
(*it)[0] == '/' &&
|
||||
it->substr(it->size()-2) == ".a")
|
||||
{
|
||||
if(select)
|
||||
intermediate.append((*it) + " ");
|
||||
}
|
||||
else if(!select)
|
||||
intermediate.append((*it) + " ");
|
||||
}
|
||||
deduplicate_tokens(intermediate, last, outstring);
|
||||
}
|
||||
|
||||
const char* usage()
|
||||
{
|
||||
return "USAGE: rospack <command> [options] [package]\n"
|
||||
" Allowed commands:\n"
|
||||
" help\n"
|
||||
" find [package]\n"
|
||||
" list\n"
|
||||
" list-names\n"
|
||||
" list-duplicates\n"
|
||||
" langs\n"
|
||||
" depends [package] (alias: deps)\n"
|
||||
" depends-manifests [package] (alias: deps-manifests)\n"
|
||||
" depends-msgsrv [package] (alias: deps-msgsrv)\n"
|
||||
" depends1 [package] (alias: deps1)\n"
|
||||
" depends-indent [package] (alias: deps-indent)\n"
|
||||
" depends-why --target=<target> [package] (alias: deps-why)\n"
|
||||
" rosdep [package] (alias: rosdeps)\n"
|
||||
" rosdep0 [package] (alias: rosdeps0)\n"
|
||||
" vcs [package]\n"
|
||||
" vcs0 [package]\n"
|
||||
" depends-on [package]\n"
|
||||
" depends-on1 [package]\n"
|
||||
" export [--deps-only] --lang=<lang> --attrib=<attrib> [package]\n"
|
||||
" plugins --attrib=<attrib> [--top=<toppkg>] [package]\n"
|
||||
" cflags-only-I [--deps-only] [package]\n"
|
||||
" cflags-only-other [--deps-only] [package]\n"
|
||||
" libs-only-L [--deps-only] [package]\n"
|
||||
" libs-only-l [--deps-only] [package]\n"
|
||||
" libs-only-other [--deps-only] [package]\n"
|
||||
" profile [--length=<length>] [--zombie-only]\n"
|
||||
" Extra options:\n"
|
||||
" -q Quiets error reports.\n\n"
|
||||
" If [package] is omitted, the current working directory\n"
|
||||
" is used (if it contains a manifest.xml).\n\n";
|
||||
}
|
||||
|
||||
bool
|
||||
parse_args(int argc, char** argv, po::variables_map& vm)
|
||||
{
|
||||
po::options_description desc("Allowed options");
|
||||
desc.add_options()
|
||||
("command", po::value<std::string>(), "command")
|
||||
("package", po::value<std::string>(), "package")
|
||||
("target", po::value<std::string>(), "target")
|
||||
("deps-only", "deps-only")
|
||||
("lang", po::value<std::string>(), "lang")
|
||||
("attrib", po::value<std::string>(), "attrib")
|
||||
("top", po::value<std::string>(), "top")
|
||||
("length", po::value<std::string>(), "length")
|
||||
("zombie-only", "zombie-only")
|
||||
("quiet,q", "quiet");
|
||||
|
||||
po::positional_options_description pd;
|
||||
pd.add("command", 1).add("package", 1);
|
||||
try
|
||||
{
|
||||
po::store(po::command_line_parser(argc, argv).options(desc).positional(pd).run(), vm);
|
||||
}
|
||||
catch(boost::program_options::error e)
|
||||
{
|
||||
rospack::log_error("rospack", std::string("failed to parse command-line options: ") + e.what());
|
||||
return false;
|
||||
}
|
||||
po::notify(vm);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2008, Willow Garage, Inc.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
* * Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "rp.h"
|
||||
#include <boost/program_options.hpp>
|
||||
|
||||
int
|
||||
main(int argc, char** argv)
|
||||
{
|
||||
rospack::Rosstack rs;
|
||||
|
||||
std::vector<std::string> search_path;
|
||||
search_path.push_back("/Users/gerkey/code/ros/ros");
|
||||
search_path.push_back("/Users/gerkey/code/ros/ros/tools/rospack");
|
||||
search_path.push_back("/Users/gerkey/code/ros/ros_comm");
|
||||
rs.crawl(search_path, false);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,530 +0,0 @@
|
|||
/** @mainpage
|
||||
|
||||
<h1> TinyXML </h1>
|
||||
|
||||
TinyXML is a simple, small, C++ XML parser that can be easily
|
||||
integrated into other programs.
|
||||
|
||||
<h2> What it does. </h2>
|
||||
|
||||
In brief, TinyXML parses an XML document, and builds from that a
|
||||
Document Object Model (DOM) that can be read, modified, and saved.
|
||||
|
||||
XML stands for "eXtensible Markup Language." It allows you to create
|
||||
your own document markups. Where HTML does a very good job of marking
|
||||
documents for browsers, XML allows you to define any kind of document
|
||||
markup, for example a document that describes a "to do" list for an
|
||||
organizer application. XML is a very structured and convenient format.
|
||||
All those random file formats created to store application data can
|
||||
all be replaced with XML. One parser for everything.
|
||||
|
||||
The best place for the complete, correct, and quite frankly hard to
|
||||
read spec is at <a href="http://www.w3.org/TR/2004/REC-xml-20040204/">
|
||||
http://www.w3.org/TR/2004/REC-xml-20040204/</a>. An intro to XML
|
||||
(that I really like) can be found at
|
||||
<a href="http://skew.org/xml/tutorial/">http://skew.org/xml/tutorial</a>.
|
||||
|
||||
There are different ways to access and interact with XML data.
|
||||
TinyXML uses a Document Object Model (DOM), meaning the XML data is parsed
|
||||
into a C++ objects that can be browsed and manipulated, and then
|
||||
written to disk or another output stream. You can also construct an XML document
|
||||
from scratch with C++ objects and write this to disk or another output
|
||||
stream.
|
||||
|
||||
TinyXML is designed to be easy and fast to learn. It is two headers
|
||||
and four cpp files. Simply add these to your project and off you go.
|
||||
There is an example file - xmltest.cpp - to get you started.
|
||||
|
||||
TinyXML is released under the ZLib license,
|
||||
so you can use it in open source or commercial code. The details
|
||||
of the license are at the top of every source file.
|
||||
|
||||
TinyXML attempts to be a flexible parser, but with truly correct and
|
||||
compliant XML output. TinyXML should compile on any reasonably C++
|
||||
compliant system. It does not rely on exceptions or RTTI. It can be
|
||||
compiled with or without STL support. TinyXML fully supports
|
||||
the UTF-8 encoding, and the first 64k character entities.
|
||||
|
||||
|
||||
<h2> What it doesn't do. </h2>
|
||||
|
||||
TinyXML doesn't parse or use DTDs (Document Type Definitions) or XSLs
|
||||
(eXtensible Stylesheet Language.) There are other parsers out there
|
||||
(check out www.sourceforge.org, search for XML) that are much more fully
|
||||
featured. But they are also much bigger, take longer to set up in
|
||||
your project, have a higher learning curve, and often have a more
|
||||
restrictive license. If you are working with browsers or have more
|
||||
complete XML needs, TinyXML is not the parser for you.
|
||||
|
||||
The following DTD syntax will not parse at this time in TinyXML:
|
||||
|
||||
@verbatim
|
||||
<!DOCTYPE Archiv [
|
||||
<!ELEMENT Comment (#PCDATA)>
|
||||
]>
|
||||
@endverbatim
|
||||
|
||||
because TinyXML sees this as a !DOCTYPE node with an illegally
|
||||
embedded !ELEMENT node. This may be addressed in the future.
|
||||
|
||||
<h2> Tutorials. </h2>
|
||||
|
||||
For the impatient, here is a tutorial to get you going. A great way to get started,
|
||||
but it is worth your time to read this (very short) manual completely.
|
||||
|
||||
- @subpage tutorial0
|
||||
|
||||
<h2> Code Status. </h2>
|
||||
|
||||
TinyXML is mature, tested code. It is very stable. If you find
|
||||
bugs, please file a bug report on the sourceforge web site
|
||||
(www.sourceforge.net/projects/tinyxml). We'll get them straightened
|
||||
out as soon as possible.
|
||||
|
||||
There are some areas of improvement; please check sourceforge if you are
|
||||
interested in working on TinyXML.
|
||||
|
||||
<h2> Related Projects </h2>
|
||||
|
||||
TinyXML projects you may find useful! (Descriptions provided by the projects.)
|
||||
|
||||
<ul>
|
||||
<li> <b>TinyXPath</b> (http://tinyxpath.sourceforge.net). TinyXPath is a small footprint
|
||||
XPath syntax decoder, written in C++.</li>
|
||||
<li> <b>TinyXML++</b> (http://code.google.com/p/ticpp/). TinyXML++ is a completely new
|
||||
interface to TinyXML that uses MANY of the C++ strengths. Templates,
|
||||
exceptions, and much better error handling.</li>
|
||||
</ul>
|
||||
|
||||
<h2> Features </h2>
|
||||
|
||||
<h3> Using STL </h3>
|
||||
|
||||
TinyXML can be compiled to use or not use STL. When using STL, TinyXML
|
||||
uses the std::string class, and fully supports std::istream, std::ostream,
|
||||
operator<<, and operator>>. Many API methods have both 'const char*' and
|
||||
'const std::string&' forms.
|
||||
|
||||
When STL support is compiled out, no STL files are included whatsoever. All
|
||||
the string classes are implemented by TinyXML itself. API methods
|
||||
all use the 'const char*' form for input.
|
||||
|
||||
Use the compile time #define:
|
||||
|
||||
TIXML_USE_STL
|
||||
|
||||
to compile one version or the other. This can be passed by the compiler,
|
||||
or set as the first line of "tinyxml.h".
|
||||
|
||||
Note: If compiling the test code in Linux, setting the environment
|
||||
variable TINYXML_USE_STL=YES/NO will control STL compilation. In the
|
||||
Windows project file, STL and non STL targets are provided. In your project,
|
||||
It's probably easiest to add the line "#define TIXML_USE_STL" as the first
|
||||
line of tinyxml.h.
|
||||
|
||||
<h3> UTF-8 </h3>
|
||||
|
||||
TinyXML supports UTF-8 allowing to manipulate XML files in any language. TinyXML
|
||||
also supports "legacy mode" - the encoding used before UTF-8 support and
|
||||
probably best described as "extended ascii".
|
||||
|
||||
Normally, TinyXML will try to detect the correct encoding and use it. However,
|
||||
by setting the value of TIXML_DEFAULT_ENCODING in the header file, TinyXML
|
||||
can be forced to always use one encoding.
|
||||
|
||||
TinyXML will assume Legacy Mode until one of the following occurs:
|
||||
<ol>
|
||||
<li> If the non-standard but common "UTF-8 lead bytes" (0xef 0xbb 0xbf)
|
||||
begin the file or data stream, TinyXML will read it as UTF-8. </li>
|
||||
<li> If the declaration tag is read, and it has an encoding="UTF-8", then
|
||||
TinyXML will read it as UTF-8. </li>
|
||||
<li> If the declaration tag is read, and it has no encoding specified, then TinyXML will
|
||||
read it as UTF-8. </li>
|
||||
<li> If the declaration tag is read, and it has an encoding="something else", then TinyXML
|
||||
will read it as Legacy Mode. In legacy mode, TinyXML will work as it did before. It's
|
||||
not clear what that mode does exactly, but old content should keep working.</li>
|
||||
<li> Until one of the above criteria is met, TinyXML runs in Legacy Mode.</li>
|
||||
</ol>
|
||||
|
||||
What happens if the encoding is incorrectly set or detected? TinyXML will try
|
||||
to read and pass through text seen as improperly encoded. You may get some strange results or
|
||||
mangled characters. You may want to force TinyXML to the correct mode.
|
||||
|
||||
You may force TinyXML to Legacy Mode by using LoadFile( TIXML_ENCODING_LEGACY ) or
|
||||
LoadFile( filename, TIXML_ENCODING_LEGACY ). You may force it to use legacy mode all
|
||||
the time by setting TIXML_DEFAULT_ENCODING = TIXML_ENCODING_LEGACY. Likewise, you may
|
||||
force it to TIXML_ENCODING_UTF8 with the same technique.
|
||||
|
||||
For English users, using English XML, UTF-8 is the same as low-ASCII. You
|
||||
don't need to be aware of UTF-8 or change your code in any way. You can think
|
||||
of UTF-8 as a "superset" of ASCII.
|
||||
|
||||
UTF-8 is not a double byte format - but it is a standard encoding of Unicode!
|
||||
TinyXML does not use or directly support wchar, TCHAR, or Microsoft's _UNICODE at this time.
|
||||
It is common to see the term "Unicode" improperly refer to UTF-16, a wide byte encoding
|
||||
of unicode. This is a source of confusion.
|
||||
|
||||
For "high-ascii" languages - everything not English, pretty much - TinyXML can
|
||||
handle all languages, at the same time, as long as the XML is encoded
|
||||
in UTF-8. That can be a little tricky, older programs and operating systems
|
||||
tend to use the "default" or "traditional" code page. Many apps (and almost all
|
||||
modern ones) can output UTF-8, but older or stubborn (or just broken) ones
|
||||
still output text in the default code page.
|
||||
|
||||
For example, Japanese systems traditionally use SHIFT-JIS encoding.
|
||||
Text encoded as SHIFT-JIS can not be read by TinyXML.
|
||||
A good text editor can import SHIFT-JIS and then save as UTF-8.
|
||||
|
||||
The <a href="http://skew.org/xml/tutorial/">Skew.org link</a> does a great
|
||||
job covering the encoding issue.
|
||||
|
||||
The test file "utf8test.xml" is an XML containing English, Spanish, Russian,
|
||||
and Simplified Chinese. (Hopefully they are translated correctly). The file
|
||||
"utf8test.gif" is a screen capture of the XML file, rendered in IE. Note that
|
||||
if you don't have the correct fonts (Simplified Chinese or Russian) on your
|
||||
system, you won't see output that matches the GIF file even if you can parse
|
||||
it correctly. Also note that (at least on my Windows machine) console output
|
||||
is in a Western code page, so that Print() or printf() cannot correctly display
|
||||
the file. This is not a bug in TinyXML - just an OS issue. No data is lost or
|
||||
destroyed by TinyXML. The console just doesn't render UTF-8.
|
||||
|
||||
|
||||
<h3> Entities </h3>
|
||||
TinyXML recognizes the pre-defined "character entities", meaning special
|
||||
characters. Namely:
|
||||
|
||||
@verbatim
|
||||
& &
|
||||
< <
|
||||
> >
|
||||
" "
|
||||
' '
|
||||
@endverbatim
|
||||
|
||||
These are recognized when the XML document is read, and translated to there
|
||||
UTF-8 equivalents. For instance, text with the XML of:
|
||||
|
||||
@verbatim
|
||||
Far & Away
|
||||
@endverbatim
|
||||
|
||||
will have the Value() of "Far & Away" when queried from the TiXmlText object,
|
||||
and will be written back to the XML stream/file as an ampersand. Older versions
|
||||
of TinyXML "preserved" character entities, but the newer versions will translate
|
||||
them into characters.
|
||||
|
||||
Additionally, any character can be specified by its Unicode code point:
|
||||
The syntax " " or " " are both to the non-breaking space characher.
|
||||
|
||||
<h3> Printing </h3>
|
||||
TinyXML can print output in several different ways that all have strengths and limitations.
|
||||
|
||||
- Print( FILE* ). Output to a std-C stream, which includes all C files as well as stdout.
|
||||
- "Pretty prints", but you don't have control over printing options.
|
||||
- The output is streamed directly to the FILE object, so there is no memory overhead
|
||||
in the TinyXML code.
|
||||
- used by Print() and SaveFile()
|
||||
|
||||
- operator<<. Output to a c++ stream.
|
||||
- Integrates with standart C++ iostreams.
|
||||
- Outputs in "network printing" mode without line breaks. Good for network transmission
|
||||
and moving XML between C++ objects, but hard for a human to read.
|
||||
|
||||
- TiXmlPrinter. Output to a std::string or memory buffer.
|
||||
- API is less concise
|
||||
- Future printing options will be put here.
|
||||
- Printing may change slightly in future versions as it is refined and expanded.
|
||||
|
||||
<h3> Streams </h3>
|
||||
With TIXML_USE_STL on TinyXML supports C++ streams (operator <<,>>) streams as well
|
||||
as C (FILE*) streams. There are some differences that you may need to be aware of.
|
||||
|
||||
C style output:
|
||||
- based on FILE*
|
||||
- the Print() and SaveFile() methods
|
||||
|
||||
Generates formatted output, with plenty of white space, intended to be as
|
||||
human-readable as possible. They are very fast, and tolerant of ill formed
|
||||
XML documents. For example, an XML document that contains 2 root elements
|
||||
and 2 declarations, will still print.
|
||||
|
||||
C style input:
|
||||
- based on FILE*
|
||||
- the Parse() and LoadFile() methods
|
||||
|
||||
A fast, tolerant read. Use whenever you don't need the C++ streams.
|
||||
|
||||
C++ style output:
|
||||
- based on std::ostream
|
||||
- operator<<
|
||||
|
||||
Generates condensed output, intended for network transmission rather than
|
||||
readability. Depending on your system's implementation of the ostream class,
|
||||
these may be somewhat slower. (Or may not.) Not tolerant of ill formed XML:
|
||||
a document should contain the correct one root element. Additional root level
|
||||
elements will not be streamed out.
|
||||
|
||||
C++ style input:
|
||||
- based on std::istream
|
||||
- operator>>
|
||||
|
||||
Reads XML from a stream, making it useful for network transmission. The tricky
|
||||
part is knowing when the XML document is complete, since there will almost
|
||||
certainly be other data in the stream. TinyXML will assume the XML data is
|
||||
complete after it reads the root element. Put another way, documents that
|
||||
are ill-constructed with more than one root element will not read correctly.
|
||||
Also note that operator>> is somewhat slower than Parse, due to both
|
||||
implementation of the STL and limitations of TinyXML.
|
||||
|
||||
<h3> White space </h3>
|
||||
The world simply does not agree on whether white space should be kept, or condensed.
|
||||
For example, pretend the '_' is a space, and look at "Hello____world". HTML, and
|
||||
at least some XML parsers, will interpret this as "Hello_world". They condense white
|
||||
space. Some XML parsers do not, and will leave it as "Hello____world". (Remember
|
||||
to keep pretending the _ is a space.) Others suggest that __Hello___world__ should become
|
||||
Hello___world.
|
||||
|
||||
It's an issue that hasn't been resolved to my satisfaction. TinyXML supports the
|
||||
first 2 approaches. Call TiXmlBase::SetCondenseWhiteSpace( bool ) to set the desired behavior.
|
||||
The default is to condense white space.
|
||||
|
||||
If you change the default, you should call TiXmlBase::SetCondenseWhiteSpace( bool )
|
||||
before making any calls to Parse XML data, and I don't recommend changing it after
|
||||
it has been set.
|
||||
|
||||
|
||||
<h3> Handles </h3>
|
||||
|
||||
Where browsing an XML document in a robust way, it is important to check
|
||||
for null returns from method calls. An error safe implementation can
|
||||
generate a lot of code like:
|
||||
|
||||
@verbatim
|
||||
TiXmlElement* root = document.FirstChildElement( "Document" );
|
||||
if ( root )
|
||||
{
|
||||
TiXmlElement* element = root->FirstChildElement( "Element" );
|
||||
if ( element )
|
||||
{
|
||||
TiXmlElement* child = element->FirstChildElement( "Child" );
|
||||
if ( child )
|
||||
{
|
||||
TiXmlElement* child2 = child->NextSiblingElement( "Child" );
|
||||
if ( child2 )
|
||||
{
|
||||
// Finally do something useful.
|
||||
@endverbatim
|
||||
|
||||
Handles have been introduced to clean this up. Using the TiXmlHandle class,
|
||||
the previous code reduces to:
|
||||
|
||||
@verbatim
|
||||
TiXmlHandle docHandle( &document );
|
||||
TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement();
|
||||
if ( child2 )
|
||||
{
|
||||
// do something useful
|
||||
@endverbatim
|
||||
|
||||
Which is much easier to deal with. See TiXmlHandle for more information.
|
||||
|
||||
|
||||
<h3> Row and Column tracking </h3>
|
||||
Being able to track nodes and attributes back to their origin location
|
||||
in source files can be very important for some applications. Additionally,
|
||||
knowing where parsing errors occured in the original source can be very
|
||||
time saving.
|
||||
|
||||
TinyXML can tracks the row and column origin of all nodes and attributes
|
||||
in a text file. The TiXmlBase::Row() and TiXmlBase::Column() methods return
|
||||
the origin of the node in the source text. The correct tabs can be
|
||||
configured in TiXmlDocument::SetTabSize().
|
||||
|
||||
|
||||
<h2> Using and Installing </h2>
|
||||
|
||||
To Compile and Run xmltest:
|
||||
|
||||
A Linux Makefile and a Windows Visual C++ .dsw file is provided.
|
||||
Simply compile and run. It will write the file demotest.xml to your
|
||||
disk and generate output on the screen. It also tests walking the
|
||||
DOM by printing out the number of nodes found using different
|
||||
techniques.
|
||||
|
||||
The Linux makefile is very generic and runs on many systems - it
|
||||
is currently tested on mingw and
|
||||
MacOSX. You do not need to run 'make depend'. The dependecies have been
|
||||
hard coded.
|
||||
|
||||
<h3>Windows project file for VC6</h3>
|
||||
<ul>
|
||||
<li>tinyxml: tinyxml library, non-STL </li>
|
||||
<li>tinyxmlSTL: tinyxml library, STL </li>
|
||||
<li>tinyXmlTest: test app, non-STL </li>
|
||||
<li>tinyXmlTestSTL: test app, STL </li>
|
||||
</ul>
|
||||
|
||||
<h3>Makefile</h3>
|
||||
At the top of the makefile you can set:
|
||||
|
||||
PROFILE, DEBUG, and TINYXML_USE_STL. Details (such that they are) are in
|
||||
the makefile.
|
||||
|
||||
In the tinyxml directory, type "make clean" then "make". The executable
|
||||
file 'xmltest' will be created.
|
||||
|
||||
|
||||
|
||||
<h3>To Use in an Application:</h3>
|
||||
|
||||
Add tinyxml.cpp, tinyxml.h, tinyxmlerror.cpp, tinyxmlparser.cpp, tinystr.cpp, and tinystr.h to your
|
||||
project or make file. That's it! It should compile on any reasonably
|
||||
compliant C++ system. You do not need to enable exceptions or
|
||||
RTTI for TinyXML.
|
||||
|
||||
|
||||
<h2> How TinyXML works. </h2>
|
||||
|
||||
An example is probably the best way to go. Take:
|
||||
@verbatim
|
||||
<?xml version="1.0" standalone=no>
|
||||
<!-- Our to do list data -->
|
||||
<ToDo>
|
||||
<Item priority="1"> Go to the <bold>Toy store!</bold></Item>
|
||||
<Item priority="2"> Do bills</Item>
|
||||
</ToDo>
|
||||
@endverbatim
|
||||
|
||||
Its not much of a To Do list, but it will do. To read this file
|
||||
(say "demo.xml") you would create a document, and parse it in:
|
||||
@verbatim
|
||||
TiXmlDocument doc( "demo.xml" );
|
||||
doc.LoadFile();
|
||||
@endverbatim
|
||||
|
||||
And its ready to go. Now lets look at some lines and how they
|
||||
relate to the DOM.
|
||||
|
||||
@verbatim
|
||||
<?xml version="1.0" standalone=no>
|
||||
@endverbatim
|
||||
|
||||
The first line is a declaration, and gets turned into the
|
||||
TiXmlDeclaration class. It will be the first child of the
|
||||
document node.
|
||||
|
||||
This is the only directive/special tag parsed by by TinyXML.
|
||||
Generally directive tags are stored in TiXmlUnknown so the
|
||||
commands wont be lost when it is saved back to disk.
|
||||
|
||||
@verbatim
|
||||
<!-- Our to do list data -->
|
||||
@endverbatim
|
||||
|
||||
A comment. Will become a TiXmlComment object.
|
||||
|
||||
@verbatim
|
||||
<ToDo>
|
||||
@endverbatim
|
||||
|
||||
The "ToDo" tag defines a TiXmlElement object. This one does not have
|
||||
any attributes, but does contain 2 other elements.
|
||||
|
||||
@verbatim
|
||||
<Item priority="1">
|
||||
@endverbatim
|
||||
|
||||
Creates another TiXmlElement which is a child of the "ToDo" element.
|
||||
This element has 1 attribute, with the name "priority" and the value
|
||||
"1".
|
||||
|
||||
@verbatim
|
||||
Go to the
|
||||
@endverbatim
|
||||
|
||||
A TiXmlText. This is a leaf node and cannot contain other nodes.
|
||||
It is a child of the "Item" TiXmlElement.
|
||||
|
||||
@verbatim
|
||||
<bold>
|
||||
@endverbatim
|
||||
|
||||
|
||||
Another TiXmlElement, this one a child of the "Item" element.
|
||||
|
||||
Etc.
|
||||
|
||||
Looking at the entire object tree, you end up with:
|
||||
@verbatim
|
||||
TiXmlDocument "demo.xml"
|
||||
TiXmlDeclaration "version='1.0'" "standalone=no"
|
||||
TiXmlComment " Our to do list data"
|
||||
TiXmlElement "ToDo"
|
||||
TiXmlElement "Item" Attribtutes: priority = 1
|
||||
TiXmlText "Go to the "
|
||||
TiXmlElement "bold"
|
||||
TiXmlText "Toy store!"
|
||||
TiXmlElement "Item" Attributes: priority=2
|
||||
TiXmlText "Do bills"
|
||||
@endverbatim
|
||||
|
||||
<h2> Documentation </h2>
|
||||
|
||||
The documentation is build with Doxygen, using the 'dox'
|
||||
configuration file.
|
||||
|
||||
<h2> License </h2>
|
||||
|
||||
TinyXML is released under the zlib license:
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
|
||||
<h2> References </h2>
|
||||
|
||||
The World Wide Web Consortium is the definitive standard body for
|
||||
XML, and there web pages contain huge amounts of information.
|
||||
|
||||
The definitive spec: <a href="http://www.w3.org/TR/2004/REC-xml-20040204/">
|
||||
http://www.w3.org/TR/2004/REC-xml-20040204/</a>
|
||||
|
||||
I also recommend "XML Pocket Reference" by Robert Eckstein and published by
|
||||
OReilly...the book that got the whole thing started.
|
||||
|
||||
<h2> Contributors, Contacts, and a Brief History </h2>
|
||||
|
||||
Thanks very much to everyone who sends suggestions, bugs, ideas, and
|
||||
encouragement. It all helps, and makes this project fun. A special thanks
|
||||
to the contributors on the web pages that keep it lively.
|
||||
|
||||
So many people have sent in bugs and ideas, that rather than list here
|
||||
we try to give credit due in the "changes.txt" file.
|
||||
|
||||
TinyXML was originally written by Lee Thomason. (Often the "I" still
|
||||
in the documentation.) Lee reviews changes and releases new versions,
|
||||
with the help of Yves Berquin, Andrew Ellerton, and the tinyXml community.
|
||||
|
||||
We appreciate your suggestions, and would love to know if you
|
||||
use TinyXML. Hopefully you will enjoy it and find it useful.
|
||||
Please post questions, comments, file bugs, or contact us at:
|
||||
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
|
||||
Lee Thomason, Yves Berquin, Andrew Ellerton
|
||||
*/
|
||||
|
|
@ -1,118 +0,0 @@
|
|||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original file by Yves Berquin.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* THIS FILE WAS ALTERED BY Tyge Løvset, 7. April 2005.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef TIXML_USE_STL
|
||||
|
||||
#include "tinystr.h"
|
||||
|
||||
namespace rospack_tinyxml {
|
||||
|
||||
// Error value for find primitive
|
||||
const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
|
||||
|
||||
|
||||
// Null rep.
|
||||
TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
|
||||
|
||||
|
||||
void TiXmlString::reserve (size_type cap)
|
||||
{
|
||||
if (cap > capacity())
|
||||
{
|
||||
TiXmlString tmp;
|
||||
tmp.init(length(), cap);
|
||||
memcpy(tmp.start(), data(), length());
|
||||
swap(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TiXmlString& TiXmlString::assign(const char* str, size_type len)
|
||||
{
|
||||
size_type cap = capacity();
|
||||
if (len > cap || cap > 3*(len + 8))
|
||||
{
|
||||
TiXmlString tmp;
|
||||
tmp.init(len);
|
||||
memcpy(tmp.start(), str, len);
|
||||
swap(tmp);
|
||||
}
|
||||
else
|
||||
{
|
||||
memmove(start(), str, len);
|
||||
set_size(len);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
TiXmlString& TiXmlString::append(const char* str, size_type len)
|
||||
{
|
||||
size_type newsize = length() + len;
|
||||
if (newsize > capacity())
|
||||
{
|
||||
reserve (newsize + capacity());
|
||||
}
|
||||
memmove(finish(), str, len);
|
||||
set_size(newsize);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
|
||||
{
|
||||
TiXmlString tmp;
|
||||
tmp.reserve(a.length() + b.length());
|
||||
tmp += a;
|
||||
tmp += b;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
TiXmlString operator + (const TiXmlString & a, const char* b)
|
||||
{
|
||||
TiXmlString tmp;
|
||||
TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
|
||||
tmp.reserve(a.length() + b_len);
|
||||
tmp += a;
|
||||
tmp.append(b, b_len);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
TiXmlString operator + (const char* a, const TiXmlString & b)
|
||||
{
|
||||
TiXmlString tmp;
|
||||
TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
|
||||
tmp.reserve(a_len + b.length());
|
||||
tmp.append(a, a_len);
|
||||
tmp += b;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
}
|
||||
#endif // TIXML_USE_STL
|
||||
|
|
@ -1,322 +0,0 @@
|
|||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original file by Yves Berquin.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
|
||||
*
|
||||
* - completely rewritten. compact, clean, and fast implementation.
|
||||
* - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
|
||||
* - fixed reserve() to work as per specification.
|
||||
* - fixed buggy compares operator==(), operator<(), and operator>()
|
||||
* - fixed operator+=() to take a const ref argument, following spec.
|
||||
* - added "copy" constructor with length, and most compare operators.
|
||||
* - added swap(), clear(), size(), capacity(), operator+().
|
||||
*/
|
||||
|
||||
#ifndef TIXML_USE_STL
|
||||
|
||||
#ifndef TIXML_STRING_INCLUDED
|
||||
#define TIXML_STRING_INCLUDED
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
/* The support for explicit isn't that universal, and it isn't really
|
||||
required - it is used to check that the TiXmlString class isn't incorrectly
|
||||
used. Be nice to old compilers and macro it here:
|
||||
*/
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
|
||||
// Microsoft visual studio, version 6 and higher.
|
||||
#define TIXML_EXPLICIT explicit
|
||||
#elif defined(__GNUC__) && (__GNUC__ >= 3 )
|
||||
// GCC version 3 and higher.s
|
||||
#define TIXML_EXPLICIT explicit
|
||||
#else
|
||||
#define TIXML_EXPLICIT
|
||||
#endif
|
||||
|
||||
namespace rospack_tinyxml {
|
||||
|
||||
/*
|
||||
TiXmlString is an emulation of a subset of the std::string template.
|
||||
Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
|
||||
Only the member functions relevant to the TinyXML project have been implemented.
|
||||
The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
|
||||
a string and there's no more room, we allocate a buffer twice as big as we need.
|
||||
*/
|
||||
class TiXmlString
|
||||
{
|
||||
public :
|
||||
// The size type used
|
||||
typedef size_t size_type;
|
||||
|
||||
// Error value for find primitive
|
||||
static const size_type npos; // = -1;
|
||||
|
||||
|
||||
// TiXmlString empty constructor
|
||||
TiXmlString () : rep_(&nullrep_)
|
||||
{
|
||||
}
|
||||
|
||||
// TiXmlString copy constructor
|
||||
TiXmlString ( const TiXmlString & copy) : rep_(0)
|
||||
{
|
||||
init(copy.length());
|
||||
memcpy(start(), copy.data(), length());
|
||||
}
|
||||
|
||||
// TiXmlString constructor, based on a string
|
||||
TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
|
||||
{
|
||||
init( static_cast<size_type>( strlen(copy) ));
|
||||
memcpy(start(), copy, length());
|
||||
}
|
||||
|
||||
// TiXmlString constructor, based on a string
|
||||
TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
|
||||
{
|
||||
init(len);
|
||||
memcpy(start(), str, len);
|
||||
}
|
||||
|
||||
// TiXmlString destructor
|
||||
~TiXmlString ()
|
||||
{
|
||||
quit();
|
||||
}
|
||||
|
||||
// = operator
|
||||
TiXmlString& operator = (const char * copy)
|
||||
{
|
||||
return assign( copy, (size_type)strlen(copy));
|
||||
}
|
||||
|
||||
// = operator
|
||||
TiXmlString& operator = (const TiXmlString & copy)
|
||||
{
|
||||
return assign(copy.start(), copy.length());
|
||||
}
|
||||
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (const char * suffix)
|
||||
{
|
||||
return append(suffix, static_cast<size_type>( strlen(suffix) ));
|
||||
}
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (char single)
|
||||
{
|
||||
return append(&single, 1);
|
||||
}
|
||||
|
||||
// += operator. Maps to append
|
||||
TiXmlString& operator += (const TiXmlString & suffix)
|
||||
{
|
||||
return append(suffix.data(), suffix.length());
|
||||
}
|
||||
|
||||
|
||||
// Convert a TiXmlString into a null-terminated char *
|
||||
const char * c_str () const { return rep_->str; }
|
||||
|
||||
// Convert a TiXmlString into a char * (need not be null terminated).
|
||||
const char * data () const { return rep_->str; }
|
||||
|
||||
// Return the length of a TiXmlString
|
||||
size_type length () const { return rep_->size; }
|
||||
|
||||
// Alias for length()
|
||||
size_type size () const { return rep_->size; }
|
||||
|
||||
// Checks if a TiXmlString is empty
|
||||
bool empty () const { return rep_->size == 0; }
|
||||
|
||||
// Return capacity of string
|
||||
size_type capacity () const { return rep_->capacity; }
|
||||
|
||||
|
||||
// single char extraction
|
||||
const char& at (size_type index) const
|
||||
{
|
||||
assert( index < length() );
|
||||
return rep_->str[ index ];
|
||||
}
|
||||
|
||||
// [] operator
|
||||
char& operator [] (size_type index) const
|
||||
{
|
||||
assert( index < length() );
|
||||
return rep_->str[ index ];
|
||||
}
|
||||
|
||||
// find a char in a string. Return TiXmlString::npos if not found
|
||||
size_type find (char lookup) const
|
||||
{
|
||||
return find(lookup, 0);
|
||||
}
|
||||
|
||||
// find a char in a string from an offset. Return TiXmlString::npos if not found
|
||||
size_type find (char tofind, size_type offset) const
|
||||
{
|
||||
if (offset >= length()) return npos;
|
||||
|
||||
for (const char* p = c_str() + offset; *p != '\0'; ++p)
|
||||
{
|
||||
if (*p == tofind) return static_cast< size_type >( p - c_str() );
|
||||
}
|
||||
return npos;
|
||||
}
|
||||
|
||||
void clear ()
|
||||
{
|
||||
//Lee:
|
||||
//The original was just too strange, though correct:
|
||||
// TiXmlString().swap(*this);
|
||||
//Instead use the quit & re-init:
|
||||
quit();
|
||||
init(0,0);
|
||||
}
|
||||
|
||||
/* Function to reserve a big amount of data when we know we'll need it. Be aware that this
|
||||
function DOES NOT clear the content of the TiXmlString if any exists.
|
||||
*/
|
||||
void reserve (size_type cap);
|
||||
|
||||
TiXmlString& assign (const char* str, size_type len);
|
||||
|
||||
TiXmlString& append (const char* str, size_type len);
|
||||
|
||||
void swap (TiXmlString& other)
|
||||
{
|
||||
Rep* r = rep_;
|
||||
rep_ = other.rep_;
|
||||
other.rep_ = r;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void init(size_type sz) { init(sz, sz); }
|
||||
void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
|
||||
char* start() const { return rep_->str; }
|
||||
char* finish() const { return rep_->str + rep_->size; }
|
||||
|
||||
struct Rep
|
||||
{
|
||||
size_type size, capacity;
|
||||
char str[1];
|
||||
};
|
||||
|
||||
void init(size_type sz, size_type cap)
|
||||
{
|
||||
if (cap)
|
||||
{
|
||||
// Lee: the original form:
|
||||
// rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
|
||||
// doesn't work in some cases of new being overloaded. Switching
|
||||
// to the normal allocation, although use an 'int' for systems
|
||||
// that are overly picky about structure alignment.
|
||||
const size_type bytesNeeded = sizeof(Rep) + cap;
|
||||
const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int );
|
||||
rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
|
||||
|
||||
rep_->str[ rep_->size = sz ] = '\0';
|
||||
rep_->capacity = cap;
|
||||
}
|
||||
else
|
||||
{
|
||||
rep_ = &nullrep_;
|
||||
}
|
||||
}
|
||||
|
||||
void quit()
|
||||
{
|
||||
if (rep_ != &nullrep_)
|
||||
{
|
||||
// The rep_ is really an array of ints. (see the allocator, above).
|
||||
// Cast it back before delete, so the compiler won't incorrectly call destructors.
|
||||
delete [] ( reinterpret_cast<int*>( rep_ ) );
|
||||
}
|
||||
}
|
||||
|
||||
Rep * rep_;
|
||||
static Rep nullrep_;
|
||||
|
||||
} ;
|
||||
|
||||
|
||||
inline bool operator == (const TiXmlString & a, const TiXmlString & b)
|
||||
{
|
||||
return ( a.length() == b.length() ) // optimization on some platforms
|
||||
&& ( strcmp(a.c_str(), b.c_str()) == 0 ); // actual compare
|
||||
}
|
||||
inline bool operator < (const TiXmlString & a, const TiXmlString & b)
|
||||
{
|
||||
return strcmp(a.c_str(), b.c_str()) < 0;
|
||||
}
|
||||
|
||||
inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
|
||||
inline bool operator > (const TiXmlString & a, const TiXmlString & b) { return b < a; }
|
||||
inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
|
||||
inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
|
||||
|
||||
inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
|
||||
inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
|
||||
inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
|
||||
inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
|
||||
|
||||
TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
|
||||
TiXmlString operator + (const TiXmlString & a, const char* b);
|
||||
TiXmlString operator + (const char* a, const TiXmlString & b);
|
||||
|
||||
|
||||
/*
|
||||
TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
|
||||
Only the operators that we need for TinyXML have been developped.
|
||||
*/
|
||||
class TiXmlOutStream : public TiXmlString
|
||||
{
|
||||
public :
|
||||
|
||||
// TiXmlOutStream << operator.
|
||||
TiXmlOutStream & operator << (const TiXmlString & in)
|
||||
{
|
||||
*this += in;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// TiXmlOutStream << operator.
|
||||
TiXmlOutStream & operator << (const char * in)
|
||||
{
|
||||
*this += in;
|
||||
return *this;
|
||||
}
|
||||
|
||||
} ;
|
||||
|
||||
}
|
||||
|
||||
#endif // TIXML_STRING_INCLUDED
|
||||
#endif // TIXML_USE_STL
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
www.sourceforge.net/projects/tinyxml
|
||||
Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product documentation
|
||||
would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and
|
||||
must not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
*/
|
||||
|
||||
#include "tinyxml.h"
|
||||
|
||||
// The goal of the seperate error file is to make the first
|
||||
// step towards localization. tinyxml (currently) only supports
|
||||
// english error messages, but the could now be translated.
|
||||
//
|
||||
// It also cleans up the code a bit.
|
||||
//
|
||||
|
||||
namespace rospack_tinyxml {
|
||||
|
||||
const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
|
||||
{
|
||||
"No error",
|
||||
"Error",
|
||||
"Failed to open file",
|
||||
"Memory allocation failed.",
|
||||
"Error parsing Element.",
|
||||
"Failed to read Element name",
|
||||
"Error reading Element value.",
|
||||
"Error reading Attributes.",
|
||||
"Error: empty tag.",
|
||||
"Error reading end tag.",
|
||||
"Error parsing Unknown.",
|
||||
"Error parsing Comment.",
|
||||
"Error parsing Declaration.",
|
||||
"Error document empty.",
|
||||
"Error null (0) or unexpected EOF found in input stream.",
|
||||
"Error parsing CDATA.",
|
||||
"Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
|
||||
};
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue