[packages/libsigrok] - up to 0.5.0
arekm
arekm at pld-linux.org
Wed Jul 4 20:37:30 CEST 2018
commit 5fadb5f6cbb0e5edee830cf054d6aa1b5f7245a9
Author: Arkadiusz Miśkiewicz <arekm at maven.pl>
Date: Wed Jul 4 20:37:23 2018 +0200
- up to 0.5.0
libsigrok-missing.patch | 431 ------------------------------------------------
libsigrok-ruby.patch | 36 ++--
libsigrok.spec | 16 +-
3 files changed, 21 insertions(+), 462 deletions(-)
---
diff --git a/libsigrok.spec b/libsigrok.spec
index a9f7014..01cc299 100644
--- a/libsigrok.spec
+++ b/libsigrok.spec
@@ -10,14 +10,14 @@
Summary: Basic hardware access drivers for logic analyzers
Summary(pl.UTF-8): Podstawowe sterowniki dostępu do sprzętu dla analizatorów logicznych
Name: libsigrok
-Version: 0.4.0
-Release: 6
+Version: 0.5.0
+Release: 1
License: GPL v3+
Group: Libraries
Source0: http://sigrok.org/download/source/libsigrok/%{name}-%{version}.tar.gz
-# Source0-md5: 6cd64b94be0b8ce7224de8c823f735aa
+# Source0-md5: 0e27c89b6b7374fa9a571d6227f6a54a
Patch0: %{name}-python.patch
-Patch1: %{name}-missing.patch
+
Patch2: %{name}-ruby.patch
Patch3: %{name}-java.patch
URL: http://www.sigrok.org/
@@ -211,7 +211,7 @@ Wiązania języka Ruby do biblioteki libsigrok.
%prep
%setup -q
%patch0 -p1
-%patch1 -p1
+
%patch2 -p1
%patch3 -p1
@@ -240,7 +240,7 @@ cd ..
%configure \
PYTHON="%{__python}" \
- --enable-all-drivers \
+ --enable-all-drivers=yes \
--enable-java%{!?with_java:=no} \
--enable-python%{!?with_python2:=no} \
--enable-ruby%{!?with_ruby:=no} \
@@ -286,7 +286,7 @@ rm -rf $RPM_BUILD_ROOT
%defattr(644,root,root,755)
%doc ChangeLog NEWS README README.devices
%attr(755,root,root) %{_libdir}/libsigrok.so.*.*.*
-%attr(755,root,root) %ghost %{_libdir}/libsigrok.so.3
+%attr(755,root,root) %ghost %{_libdir}/libsigrok.so.4
/lib/udev/rules.d/60-libsigrok.rules
%{_datadir}/sigrok-firmware
@@ -306,7 +306,7 @@ rm -rf $RPM_BUILD_ROOT
%files c++
%defattr(644,root,root,755)
%attr(755,root,root) %{_libdir}/libsigrokcxx.so.*.*.*
-%attr(755,root,root) %ghost %{_libdir}/libsigrokcxx.so.3
+%attr(755,root,root) %ghost %{_libdir}/libsigrokcxx.so.4
%files c++-devel
%defattr(644,root,root,755)
diff --git a/libsigrok-missing.patch b/libsigrok-missing.patch
deleted file mode 100644
index 7044855..0000000
--- a/libsigrok-missing.patch
+++ /dev/null
@@ -1,431 +0,0 @@
---- libsigrok-0.4.0/bindings/ruby/classes.i.orig 1970-01-01 01:00:00.000000000 +0100
-+++ libsigrok-0.4.0/bindings/ruby/classes.i 2016-06-30 21:17:12.340108319 +0200
-@@ -0,0 +1,428 @@
-+/*
-+ * This file is part of the libsigrok project.
-+ *
-+ * Copyright (C) 2016 Aurelien Jacobs <aurel at gnuage.org>
-+ *
-+ * This program is free software: you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation, either version 2 of the License, or
-+ * (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
-+ */
-+
-+%define DOCSTRING
-+"
-+= Introduction
-+
-+The sigrok Ruby API provides an object-oriented Ruby interface to the
-+functionality in libsigrok. It is built on top of the libsigrokcxx C++ API.
-+
-+= Getting started
-+
-+Usage of the sigrok Ruby API needs to begin with a call to Context.create().
-+This will create the global libsigrok context and returns a Context object.
-+Methods on this object provide access to the hardware drivers, input and output
-+formats supported by the library, as well as means of creating other objects
-+such as sessions and triggers.
-+
-+= Error handling
-+
-+When any libsigrok C API call returns an error, an Error exception is raised,
-+which provides access to the error code and description."
-+%enddef
-+
-+%module(docstring=DOCSTRING) sigrok
-+
-+%{
-+#include <stdio.h>
-+#include <glibmm.h>
-+
-+#include "config.h"
-+%}
-+
-+%include "../swig/templates.i"
-+
-+%{
-+static const char *string_from_ruby(VALUE obj)
-+{
-+ switch (TYPE(obj)) {
-+ case T_STRING:
-+ return StringValueCStr(obj);
-+ case T_SYMBOL:
-+ return rb_id2name(SYM2ID(obj));
-+ default:
-+ throw sigrok::Error(SR_ERR_ARG);
-+ }
-+}
-+
-+/* Convert from Glib::Variant to native Ruby types. */
-+static VALUE variant_to_ruby(Glib::VariantBase variant)
-+{
-+ if (variant.is_of_type(Glib::VARIANT_TYPE_BOOL)) {
-+ return Glib::VariantBase::cast_dynamic< Glib::Variant<bool> >(variant).get() ? Qtrue : Qfalse;
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_BYTE)) {
-+ return UINT2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<unsigned char> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_INT16)) {
-+ return INT2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<gint16> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_UINT16)) {
-+ return UINT2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<guint16> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_INT32)) {
-+ return INT2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<gint32> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_UINT32)) {
-+ return UINT2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<guint32> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_INT64)) {
-+ return LL2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<gint64> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_UINT64)) {
-+ return ULL2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<guint64> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_DOUBLE)) {
-+ return DBL2NUM(Glib::VariantBase::cast_dynamic< Glib::Variant<double> >(variant).get());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_STRING)) {
-+ auto str = Glib::VariantBase::cast_dynamic< Glib::Variant<std::string> >(variant).get();
-+ return rb_str_new(str.c_str(), str.length());
-+ } else if (variant.is_of_type(Glib::VARIANT_TYPE_VARIANT)) {
-+ auto var = Glib::VariantBase::cast_dynamic< Glib::Variant<Glib::VariantBase> >(variant).get();
-+ return variant_to_ruby(var);
-+ } else if (variant.is_container()) {
-+ Glib::VariantContainerBase container = Glib::VariantBase::cast_dynamic< Glib::VariantContainerBase > (variant);
-+ gsize count = container.get_n_children();
-+ if (container.is_of_type(Glib::VARIANT_TYPE_DICTIONARY)) {
-+ VALUE hash = rb_hash_new();
-+ for (gsize i = 0; i < count; i++) {
-+ Glib::VariantContainerBase entry = Glib::VariantBase::cast_dynamic< Glib::VariantContainerBase > (container.get_child(i));
-+ VALUE key = variant_to_ruby(entry.get_child(0));
-+ VALUE val = variant_to_ruby(entry.get_child(1));
-+ rb_hash_aset(hash, key, val);
-+ }
-+ return hash;
-+ } else if (container.is_of_type(Glib::VARIANT_TYPE_ARRAY) ||
-+ container.is_of_type(Glib::VARIANT_TYPE_TUPLE)) {
-+ VALUE array = rb_ary_new2(count);
-+ for (gsize i = 0; i < count; i++) {
-+ VALUE val = variant_to_ruby(container.get_child(i));
-+ rb_ary_store(array, i, val);
-+ }
-+ return array;
-+ }
-+ } else {
-+ SWIG_exception(SWIG_TypeError, ("TODO: GVariant(" + variant.get_type().get_string() + ") -> Ruby").c_str());
-+ }
-+}
-+%}
-+
-+/* Map from Glib::Variant to native Ruby types. */
-+%typemap(out) Glib::VariantBase {
-+ $result = variant_to_ruby($1);
-+}
-+
-+/* Map from Glib::VariantContainer to native Ruby types. */
-+%typemap(out) Glib::VariantContainerBase {
-+ $result = variant_to_ruby($1);
-+}
-+
-+/* Map from callable Ruby Proc to LogCallbackFunction */
-+%typemap(in) sigrok::LogCallbackFunction {
-+ if (!rb_obj_is_proc($input))
-+ SWIG_exception(SWIG_TypeError, "Expected a callable Ruby object");
-+
-+ std::shared_ptr<VALUE> proc(new VALUE($input), rb_gc_unregister_address);
-+ rb_gc_register_address(proc.get());
-+
-+ $1 = [=] (const sigrok::LogLevel *loglevel, std::string message) {
-+ VALUE log_obj = SWIG_NewPointerObj(
-+ SWIG_as_voidptr(loglevel), SWIGTYPE_p_sigrok__LogLevel, 0);
-+
-+ VALUE string_obj = rb_external_str_new_with_enc(message.c_str(), message.length(), rb_utf8_encoding());
-+
-+ VALUE args = rb_ary_new_from_args(2, log_obj, string_obj);
-+ rb_proc_call(*proc.get(), args);
-+ };
-+}
-+
-+/* Map from callable Ruby Proc to SessionStoppedCallback */
-+%typemap(in) sigrok::SessionStoppedCallback {
-+ if (!rb_obj_is_proc($input))
-+ SWIG_exception(SWIG_TypeError, "Expected a callable Ruby object");
-+
-+ std::shared_ptr<VALUE> proc(new VALUE($input), rb_gc_unregister_address);
-+ rb_gc_register_address(proc.get());
-+
-+ $1 = [=] () {
-+ rb_proc_call(*proc.get(), rb_ary_new());
-+ };
-+}
-+
-+/* Map from callable Ruby Proc to DatafeedCallbackFunction */
-+%typemap(in) sigrok::DatafeedCallbackFunction {
-+ if (!rb_obj_is_proc($input))
-+ SWIG_exception(SWIG_TypeError, "Expected a callable Ruby object");
-+
-+ std::shared_ptr<VALUE> proc(new VALUE($input), rb_gc_unregister_address);
-+ rb_gc_register_address(proc.get());
-+
-+ $1 = [=] (std::shared_ptr<sigrok::Device> device,
-+ std::shared_ptr<sigrok::Packet> packet) {
-+ VALUE device_obj = SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Device>(device)),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Device_t, SWIG_POINTER_OWN);
-+
-+ VALUE packet_obj = SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Packet>(packet)),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Packet_t, SWIG_POINTER_OWN);
-+
-+ VALUE args = rb_ary_new_from_args(2, device_obj, packet_obj);
-+ rb_proc_call(*proc.get(), args);
-+ };
-+}
-+
-+/* Cast PacketPayload pointers to correct subclass type. */
-+%ignore sigrok::Packet::payload;
-+%rename sigrok::Packet::_payload payload;
-+%extend sigrok::Packet
-+{
-+ VALUE _payload()
-+ {
-+ if ($self->type() == sigrok::PacketType::HEADER) {
-+ return SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Header>(dynamic_pointer_cast<sigrok::Header>($self->payload()))),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Header_t, SWIG_POINTER_OWN);
-+ } else if ($self->type() == sigrok::PacketType::META) {
-+ return SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Meta>(dynamic_pointer_cast<sigrok::Meta>($self->payload()))),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Meta_t, SWIG_POINTER_OWN);
-+ } else if ($self->type() == sigrok::PacketType::ANALOG) {
-+ return SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Analog>(dynamic_pointer_cast<sigrok::Analog>($self->payload()))),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Analog_t, SWIG_POINTER_OWN);
-+ } else if ($self->type() == sigrok::PacketType::LOGIC) {
-+ return SWIG_NewPointerObj(
-+ SWIG_as_voidptr(new std::shared_ptr<sigrok::Logic>(dynamic_pointer_cast<sigrok::Logic>($self->payload()))),
-+ SWIGTYPE_p_std__shared_ptrT_sigrok__Logic_t, SWIG_POINTER_OWN);
-+ } else {
-+ return Qnil;
-+ }
-+ }
-+}
-+
-+%{
-+
-+#include "libsigrokcxx/libsigrokcxx.hpp"
-+
-+/* Convert from a Ruby type to Glib::Variant, according to config key data type. */
-+Glib::VariantBase ruby_to_variant_by_key(VALUE input, const sigrok::ConfigKey *key)
-+{
-+ enum sr_datatype type = (enum sr_datatype) key->data_type()->id();
-+
-+ if (type == SR_T_UINT64 && RB_TYPE_P(input, T_FIXNUM))
-+ return Glib::Variant<guint64>::create(NUM2ULL(input));
-+ if (type == SR_T_UINT64 && RB_TYPE_P(input, T_BIGNUM))
-+ return Glib::Variant<guint64>::create(NUM2ULL(input));
-+ else if (type == SR_T_STRING && RB_TYPE_P(input, T_STRING))
-+ return Glib::Variant<Glib::ustring>::create(string_from_ruby(input));
-+ else if (type == SR_T_STRING && RB_TYPE_P(input, T_SYMBOL))
-+ return Glib::Variant<Glib::ustring>::create(string_from_ruby(input));
-+ else if (type == SR_T_BOOL && RB_TYPE_P(input, T_TRUE))
-+ return Glib::Variant<bool>::create(true);
-+ else if (type == SR_T_BOOL && RB_TYPE_P(input, T_FALSE))
-+ return Glib::Variant<bool>::create(false);
-+ else if (type == SR_T_FLOAT && RB_TYPE_P(input, T_FLOAT))
-+ return Glib::Variant<double>::create(RFLOAT_VALUE(input));
-+ else if (type == SR_T_INT32 && RB_TYPE_P(input, T_FIXNUM))
-+ return Glib::Variant<gint32>::create(NUM2INT(input));
-+ else
-+ throw sigrok::Error(SR_ERR_ARG);
-+}
-+
-+/* Convert from a Ruby type to Glib::Variant, according to Option data type. */
-+Glib::VariantBase ruby_to_variant_by_option(VALUE input, std::shared_ptr<sigrok::Option> option)
-+{
-+ Glib::VariantBase variant = option->default_value();
-+
-+ if (variant.is_of_type(Glib::VARIANT_TYPE_UINT64) && RB_TYPE_P(input, T_FIXNUM))
-+ return Glib::Variant<guint64>::create(NUM2ULL(input));
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_UINT64) && RB_TYPE_P(input, T_BIGNUM))
-+ return Glib::Variant<guint64>::create(NUM2ULL(input));
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_STRING) && RB_TYPE_P(input, T_STRING))
-+ return Glib::Variant<Glib::ustring>::create(string_from_ruby(input));
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_STRING) && RB_TYPE_P(input, T_SYMBOL))
-+ return Glib::Variant<Glib::ustring>::create(string_from_ruby(input));
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_BOOL) && RB_TYPE_P(input, T_TRUE))
-+ return Glib::Variant<bool>::create(true);
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_BOOL) && RB_TYPE_P(input, T_FALSE))
-+ return Glib::Variant<bool>::create(false);
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_DOUBLE) && RB_TYPE_P(input, T_FLOAT))
-+ return Glib::Variant<double>::create(RFLOAT_VALUE(input));
-+ else if (variant.is_of_type(Glib::VARIANT_TYPE_INT32) && RB_TYPE_P(input, T_FIXNUM))
-+ return Glib::Variant<gint32>::create(NUM2INT(input));
-+ else
-+ throw sigrok::Error(SR_ERR_ARG);
-+}
-+
-+struct hash_to_map_options_params {
-+ std::map<std::string, std::shared_ptr<sigrok::Option> > options;
-+ std::map<std::string, Glib::VariantBase> output;
-+};
-+
-+int convert_option(VALUE key, VALUE val, VALUE in) {
-+ struct hash_to_map_options_params *params;
-+ params = (struct hash_to_map_options_params *)in;
-+
-+ auto k = string_from_ruby(key);
-+ auto v = ruby_to_variant_by_option(val, params->options[k]);
-+ params->output[k] = v;
-+
-+ return ST_CONTINUE;
-+}
-+
-+/* Convert from a Ruby hash to a std::map<std::string, Glib::VariantBase> */
-+std::map<std::string, Glib::VariantBase> hash_to_map_options(VALUE hash,
-+ std::map<std::string, std::shared_ptr<sigrok::Option> > options)
-+{
-+ if (!RB_TYPE_P(hash, T_HASH))
-+ throw sigrok::Error(SR_ERR_ARG);
-+
-+ struct hash_to_map_options_params params = { options };
-+ rb_hash_foreach(hash, (int (*)(ANYARGS))convert_option, (VALUE)¶ms);
-+
-+ return params.output;
-+}
-+
-+int convert_option_by_key(VALUE key, VALUE val, VALUE in) {
-+ std::map<const sigrok::ConfigKey *, Glib::VariantBase> *options;
-+ options = (std::map<const sigrok::ConfigKey *, Glib::VariantBase> *)in;
-+
-+ auto k = sigrok::ConfigKey::get_by_identifier(string_from_ruby(key));
-+ auto v = ruby_to_variant_by_key(val, k);
-+ (*options)[k] = v;
-+
-+ return ST_CONTINUE;
-+}
-+
-+%}
-+
-+/* Ignore these methods, we will override them below. */
-+%ignore sigrok::Analog::data;
-+%ignore sigrok::Driver::scan;
-+%ignore sigrok::Input::send;
-+%ignore sigrok::InputFormat::create_input;
-+%ignore sigrok::OutputFormat::create_output;
-+
-+%include "doc.i"
-+
-+%define %attributevector(Class, Type, Name, Get)
-+%alias sigrok::Class::_ ## Get #Name;
-+%enddef
-+
-+%define %attributemap(Class, Type, Name, Get)
-+%alias sigrok::Class::_ ## Get #Name;
-+%enddef
-+
-+%define %enumextras(Class)
-+%extend sigrok::Class
-+{
-+ VALUE to_s()
-+ {
-+ std::string str = $self->name();
-+ return rb_external_str_new_with_enc(str.c_str(), str.length(), rb_utf8_encoding());
-+ }
-+
-+ bool operator==(void *other)
-+ {
-+ return (long) $self == (long) other;
-+ }
-+}
-+%enddef
-+
-+%include "../swig/classes.i"
-+
-+/* Replace the original Driver.scan with a keyword arguments version. */
-+%rename sigrok::Driver::_scan scan;
-+%extend sigrok::Driver
-+{
-+ std::vector<std::shared_ptr<sigrok::HardwareDevice> > _scan(VALUE kwargs = rb_hash_new())
-+ {
-+ if (!RB_TYPE_P(kwargs, T_HASH))
-+ throw sigrok::Error(SR_ERR_ARG);
-+
-+ std::map<const sigrok::ConfigKey *, Glib::VariantBase> options;
-+ rb_hash_foreach(kwargs, (int (*)(ANYARGS))convert_option_by_key, (VALUE)&options);
-+
-+ return $self->scan(options);
-+ }
-+}
-+
-+/* Support Input.send() with string argument. */
-+%rename sigrok::Input::_send send;
-+%extend sigrok::Input
-+{
-+ void _send(VALUE data)
-+ {
-+ data = StringValue(data);
-+ return $self->send(RSTRING_PTR(data), RSTRING_LEN(data));
-+ }
-+}
-+
-+/* Support InputFormat.create_input() with keyword arguments. */
-+%rename sigrok::InputFormat::_create_input create_input;
-+%extend sigrok::InputFormat
-+{
-+ std::shared_ptr<sigrok::Input> _create_input(VALUE hash = rb_hash_new())
-+ {
-+ return $self->create_input(hash_to_map_options(hash, $self->options()));
-+ }
-+}
-+
-+/* Support OutputFormat.create_output() with keyword arguments. */
-+%rename sigrok::OutputFormat::_create_output create_output;
-+%extend sigrok::OutputFormat
-+{
-+ std::shared_ptr<sigrok::Output> _create_output(
-+ std::shared_ptr<sigrok::Device> device, VALUE hash = rb_hash_new())
-+ {
-+ return $self->create_output(device,
-+ hash_to_map_options(hash, $self->options()));
-+ }
-+
-+ std::shared_ptr<sigrok::Output> _create_output(string filename,
-+ std::shared_ptr<sigrok::Device> device, VALUE hash = rb_hash_new())
-+ {
-+ return $self->create_output(filename, device,
-+ hash_to_map_options(hash, $self->options()));
-+ }
-+}
-+
-+/* Support config_set() with Ruby input types. */
-+%extend sigrok::Configurable
-+{
-+ void config_set(const ConfigKey *key, VALUE input)
-+ {
-+ $self->config_set(key, ruby_to_variant_by_key(input, key));
-+ }
-+}
-+
-+/* Return Ruby array from Analog::data(). */
-+%rename sigrok::Analog::_data data;
-+%extend sigrok::Analog
-+{
-+ VALUE _data()
-+ {
-+ int num_channels = $self->channels().size();
-+ int num_samples = $self->num_samples();
-+ float *data = (float *) $self->data_pointer();
-+ VALUE channels = rb_ary_new2(num_channels);
-+ for(int i = 0; i < num_channels; i++) {
-+ VALUE samples = rb_ary_new2(num_samples);
-+ for (int j = 0; j < num_samples; j++) {
-+ rb_ary_store(samples, j, DBL2NUM(data[i*num_samples+j]));
-+ }
-+ rb_ary_store(channels, i, samples);
-+ }
-+ return channels;
-+ }
-+}
diff --git a/libsigrok-ruby.patch b/libsigrok-ruby.patch
index 5ceaaa4..5c6f179 100644
--- a/libsigrok-ruby.patch
+++ b/libsigrok-ruby.patch
@@ -1,26 +1,3 @@
---- libsigrok-0.4.0/Makefile.am.orig 2016-06-30 21:35:37.630787111 +0200
-+++ libsigrok-0.4.0/Makefile.am 2016-07-01 05:59:31.576995763 +0200
-@@ -675,16 +675,16 @@
- $(nodist_library_include_HEADERS) \
- $(bindings_cxx_libsigrokcxx_la_include_HEADERS) \
- $(nodist_bindings_cxx_libsigrokcxx_la_include_HEADERS)
-- $(AM_V_CXX)$(CXX) $(RBSIGROK_CFLAGS) -I. -Iinclude -Ibindings/cxx/include -fPIC -o $@ -c $<
-+ $(AM_V_CXX)$(CXX) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CPPFLAGS) $(CPPFLAGS) $(RBSIGROK_CFLAGS) -I. -Iinclude -Ibindings/cxx/include -fPIC -o $@ -c $<
-
- $(REXT): $(ROBJ) @ORDER@ bindings/cxx/libsigrokcxx.la
-- $(AM_V_CXXLD)$(CXX) -shared -std=c++11 -o $@ $< -lsigrokcxx -Lbindings/cxx/.libs $(RBSIGROK_LIBS)
-+ $(AM_V_CXXLD)$(CXX) $(AM_CXXFLAGS) $(CXXFLAGS) -shared -std=c++11 -o $@ $< -lsigrokcxx -Lbindings/cxx/.libs $(RBSIGROK_LIBS)
-
- ruby-build: $(REXT)
-
- ruby-install: $(REXT)
-- $(INSTALL) -d $(DESTDIR)$(prefix)/$(RBSIGROK_EXTDIR)
-- $(INSTALL) $< $(DESTDIR)$(prefix)/$(RBSIGROK_EXTDIR)
-+ $(INSTALL) -d $(DESTDIR)$(RBSIGROK_EXTDIR)
-+ $(INSTALL) $< $(DESTDIR)$(RBSIGROK_EXTDIR)
-
- ruby-clean:
- -$(AM_V_at)rm -fr $(RDIR)/doc
--- libsigrok-0.4.0/configure.ac.orig 2016-01-29 23:44:34.000000000 +0100
+++ libsigrok-0.4.0/configure.ac 2016-07-02 08:53:49.128940025 +0200
@@ -506,7 +506,7 @@
@@ -32,3 +9,16 @@
])
# Check for specific libusb features, now that we know the CFLAGS.
+--- libsigrok-0.5.0/Makefile.am~ 2018-07-04 20:24:21.000000000 +0200
++++ libsigrok-0.5.0/Makefile.am 2018-07-04 20:30:43.023460726 +0200
+@@ -757,8 +757,8 @@ $(REXT): $(ROBJ) @ORDER@ bindings/cxx/li
+ ruby-build: $(REXT)
+
+ ruby-install: $(REXT)
+- $(INSTALL) -d $(DESTDIR)$(prefix)/$(RBSIGROK_EXTDIR)
+- $(INSTALL) $(REXT) $(DESTDIR)$(prefix)/$(RBSIGROK_EXTDIR)
++ $(INSTALL) -d $(DESTDIR)$(RBSIGROK_EXTDIR)
++ $(INSTALL) $(REXT) $(DESTDIR)$(RBSIGROK_EXTDIR)
+
+ ruby-uninstall:
+ rm -f $(DESTDIR)$(prefix)/$(RBSIGROK_EXTDIR)/sigrok.$(RUBY_DLEXT)
================================================================
---- gitweb:
http://git.pld-linux.org/gitweb.cgi/packages/libsigrok.git/commitdiff/5fadb5f6cbb0e5edee830cf054d6aa1b5f7245a9
More information about the pld-cvs-commit
mailing list