avalara_sdk 24.12.1 → 24.12.2

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/ext/debase_internals.h

@@ -0,0 +1,124 @@
+#ifndef DEBASE_INTERNALS
+#define DEBASE_INTERNALS
+
+#include "ruby.h"
+#include "ruby/debug.h"
+
+#include <version.h>
+#if RUBY_API_VERSION_CODE == 20500
+    #include <vm_core.h>
+    #include <iseq.h>
+#endif
+
+#if RUBY_API_VERSION_CODE >= 30000
+    #include <internal/hash.h>
+#endif
+
+typedef struct rb_trace_arg_struct rb_trace_point_t;
+
+/* Debase::Context */
+/* flags */
+#define CTX_FL_SUSPEND      (1<<1)
+#define CTX_FL_TRACING      (1<<2)
+#define CTX_FL_SKIPPED      (1<<3)
+#define CTX_FL_IGNORE       (1<<4)
+#define CTX_FL_DEAD         (1<<5)
+#define CTX_FL_WAS_RUNNING  (1<<6)
+#define CTX_FL_ENABLE_BKPT  (1<<7)
+#define CTX_FL_STEPPED      (1<<8)
+#define CTX_FL_FORCE_MOVE   (1<<9)
+#define CTX_FL_CATCHING     (1<<10)
+#define CTX_FL_UPDATE_STACK (1<<11)
+
+/* macro functions */
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+
+#define IS_THREAD_ALIVE(t) (rb_funcall((t), idAlive, 0) == Qtrue)
+#define TRACE_POINT (rb_tracearg_from_tracepoint(trace_point))
+
+/* types */
+typedef enum {CTX_STOP_NONE, CTX_STOP_STEP, CTX_STOP_BREAKPOINT, CTX_STOP_CATCHPOINT} ctx_stop_reason;
+
+typedef struct debug_frame_t
+{
+    struct debug_frame_t *prev;
+    const char *file;
+    int line;
+    VALUE binding;
+    VALUE self;
+} debug_frame_t;
+
+typedef struct debug_context {
+  debug_frame_t *stack;
+  int stack_size;
+
+  VALUE thread;
+  int thnum;
+  int flags;
+  
+  ctx_stop_reason stop_reason;
+  int stop_next;
+  int stop_line;
+  int stop_frame;
+  int thread_pause;
+
+  /* dest_frame uses calced_stack_size for stepping */
+  int dest_frame;
+  int calced_stack_size;
+
+  char *last_file;
+  int last_line;
+  int init_stack_size;
+  int script_finished;
+  int hit_user_code;
+} debug_context_t;
+
+typedef struct
+{
+  debug_context_t *context;
+  VALUE context_object;
+  VALUE path;
+  VALUE lineno;
+} inspector_data_t;
+
+/* functions */
+extern VALUE Init_context(VALUE mDebase);
+extern VALUE context_create(VALUE thread, VALUE cDebugThread);
+extern void reset_stepping_stop_points(debug_context_t *context);
+extern VALUE Context_ignored(VALUE self);
+extern void fill_stack(debug_context_t *context, const rb_debug_inspector_t *inspector);
+extern void clear_stack(debug_context_t *context);
+
+/* locked threads container */
+/* types */
+typedef struct locked_thread_t {
+    VALUE thread;
+    struct locked_thread_t *next;
+} locked_thread_t;
+
+/* functions */
+extern int is_in_locked(VALUE thread_id);
+extern void add_to_locked(VALUE thread);
+extern VALUE remove_from_locked();
+extern VALUE enable_trace_points();
+
+/* breakpoints and catchpoints */
+/* types */
+typedef struct
+{
+  VALUE enabled;
+  VALUE source;
+  VALUE expr;
+  int line;
+  int id;
+} breakpoint_t;
+
+extern VALUE catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name);
+extern VALUE breakpoint_find(VALUE breakpoints, VALUE source, VALUE pos, VALUE trace_point);
+extern void Init_breakpoint(VALUE mDebase);
+
+extern void breakpoint_init_variables();
+extern void context_init_variables();
+#endif

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/ext/extconf.rb

@@ -0,0 +1,75 @@
+if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
+  # create dummy Makefile to indicate success
+  f = File.open(File.join(File.dirname(__FILE__), "Makefile"), "w")
+  f.write("all:\n\techo all\ninstall:\n\techo installed\n")
+  f.close
+  return
+end
+
+# autodetect ruby headers
+unless ARGV.any? {|arg| arg.include?('--with-ruby-include') }
+  require 'rbconfig'
+  bindir = RbConfig::CONFIG['bindir']
+  if bindir =~ %r{(^.*/\.rbenv/versions)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-1.9.1/ruby-#{$2}"
+    ruby_include = "#{ENV['RBENV_ROOT']}/sources/#{$2}/ruby-#{$2}" unless File.exist?(ruby_include)
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  elsif bindir =~ %r{(^.*/\.rvm/rubies)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-1.9.1/#{$2}"
+    ruby_include = "#{ENV['rvm_path']}/src/#{$2}" unless File.exist?(ruby_include)
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  end
+end
+
+require "mkmf"
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+require "debase/ruby_core_source"
+
+hdrs = proc {
+  have_header("vm_core.h") and
+  (have_header("iseq.h") or have_header("iseq.h", ["vm_core.h"])) and
+  have_header("version.h")
+}
+
+# Allow use customization of compile options. For example, the
+# following lines could be put in config_options to to turn off
+# optimization:
+#   $CFLAGS='-fPIC -fno-strict-aliasing -g3 -ggdb -O2 -fPIC'
+config_file = File.join(File.dirname(__FILE__), 'config_options.rb')
+load config_file if File.exist?(config_file)
+cflags = [$CFLAGS]
+cflags.push(*%w[
+  -Werror=implicit-function-declaration
+  -Werror=discarded-qualifiers
+  -Werror=incompatible-pointer-types
+])
+
+if RbConfig::MAKEFILE_CONFIG['CC'].include?('clang')
+  cflags.push(*%w[
+  -Werror=incompatible-function-pointer-types
+])
+end
+
+
+if ENV['debase_debug']
+  cflags.push(*%w[
+    -Wall
+    -Werror
+    -g3
+  ])
+end
+
+$CFLAGS += ' ' + cflags.join(' ')
+
+
+dir_config("ruby")
+if !Debase::RubyCoreSource.create_makefile_with_core(hdrs, "debase_internals")
+  STDERR.print("Makefile creation failed\n")
+  STDERR.print("*************************************************************\n\n")
+  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+  STDERR.print("*************************************************************\n\n")
+  exit(1)
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/ext/hacks.h

@@ -0,0 +1,31 @@
+#include <vm_core.h>
+#include <version.h>
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+
+#if RUBY_API_VERSION_CODE >= 20500
+  #if (RUBY_RELEASE_YEAR == 2017 && RUBY_RELEASE_MONTH == 10 && RUBY_RELEASE_DAY == 10) //workaround for 2.5.0-preview1
+    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->ec.cfp)
+    #define TH_INFO(thread) ((rb_thread_t *)thread)
+  #else
+    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->ec->cfp)
+    #define TH_INFO(thread) ((rb_execution_context_t *)(thread)->ec)
+  #endif
+#else
+  #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->cfp)
+  #define TH_INFO(thread) ((rb_thread_t *)thread)
+#endif
+
+extern void
+update_stack_size(debug_context_t *context) 
+{
+  rb_thread_t *thread;
+
+  thread = ruby_current_thread;
+  /* see backtrace_each in vm_backtrace.c */
+  context->stack_size = (int)(RUBY_VM_END_CONTROL_FRAME(TH_INFO(thread)) - TH_CFP(thread) - 1);
+  if (CTX_FL_TEST(context, CTX_FL_UPDATE_STACK)) {
+    context->calced_stack_size = context->stack_size;
+    CTX_FL_UNSET(context, CTX_FL_UPDATE_STACK);
+  }
+}

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/ext/locker.c

@@ -0,0 +1,52 @@
+#include <debase_internals.h>
+static locked_thread_t *locked_head = NULL;
+static locked_thread_t *locked_tail = NULL;
+
+extern int
+is_in_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if(!locked_head) return 0;
+
+  for(node = locked_head; node != locked_tail; node = node->next)
+  {
+    if(node->thread == thread) return 1;
+  }
+  return 0;
+}
+
+extern void
+add_to_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if(is_in_locked(thread)) return;
+
+  node = ALLOC(locked_thread_t);
+  node->thread = thread;
+  node->next = NULL;
+  if(locked_tail)
+    locked_tail->next = node;
+  locked_tail = node;
+  if(!locked_head)
+    locked_head = node;
+}
+
+extern VALUE
+remove_from_locked()
+{
+  VALUE thread;
+  locked_thread_t *node;
+
+  if(locked_head == NULL)
+    return Qnil;
+
+  node = locked_head;
+  locked_head = locked_head->next;
+  if(locked_tail == node)
+    locked_tail = NULL;
+  thread = node->thread;
+  xfree(node);
+  return thread;
+}

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/context.rb

@@ -0,0 +1,42 @@
+module Debase
+  class Context
+    def frame_locals(frame_no=0)
+      frame_binding(frame_no).eval('local_variables.inject({}){|__h, __v| __h[__v.to_s] = eval(__v.to_s); __h}')
+    rescue => e
+      {'debase-debug' => "*Evaluation error: '#{e}'" }
+    end
+
+    def frame_class(frame_no=0)
+      frame_self(frame_no).class
+    end
+
+    def frame_args_info(frame_no=0)
+      nil
+    end
+
+    def handler
+      Debase.handler or raise "No interface loaded"
+    end
+
+    def at_breakpoint(breakpoint)
+      handler.at_breakpoint(self, breakpoint)
+    end
+
+    def at_catchpoint(excpt)
+      handler.at_catchpoint(self, excpt)
+    end
+
+    def at_tracing(file, line)
+      @tracing_started = true if File.identical?(file, File.join(Debugger::INITIAL_DIR, Debugger::PROG_SCRIPT))
+      handler.at_tracing(self, file, line) if @tracing_started
+    end
+
+    def at_line(file, line)
+      handler.at_line(self, file, line)
+    end
+
+    def at_return(file, line)
+      handler.at_return(self, file, line)
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/rbx/breakpoint.rb

@@ -0,0 +1,26 @@
+module Debase
+  class Breakpoint
+    @@global_id = 1
+
+    attr_accessor :source, :pos, :expr, :enabled
+    attr_reader :id
+
+    def initialize(file, line, expr=nil)
+      @source = file
+      @pos = line
+      @expr = expr
+      @id = @@global_id
+      @@global_id = @@global_id + 1
+    end
+
+    def delete!
+
+    end
+
+    def self.remove(breakpoints, id)
+      bp = breakpoints.delete_if {|b| b.id == id}
+      bp.delete! if bp
+      bp
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/rbx/context.rb

@@ -0,0 +1,58 @@
+require 'debase/rbx/frame'
+
+module Debase
+	class Context
+    @@max_thread_num = 1
+    attr_reader :thread, :thnum
+
+    def initialize(thread)
+      @thread = thread
+      @thnum = @@max_thread_num
+      @@max_thread_num = @@max_thread_num + 1
+    end
+
+    def frame_file(frame=0)
+      @frames[frame].file
+    end
+
+    def frame_line(frame=0)
+      @frames[frame].line
+    end
+
+    def frame_binding(frame=0)
+      @frames[frame].binding
+    end
+
+    def frame_self(frame=0)
+      @frames[frame].self
+    end
+
+    def stack_size
+      @frames.size
+    end
+
+    def fill_frame_info(locations)
+      @frames = []
+      locations.each do |loc|
+        @frames << Frame.new(loc)
+      end
+      @frames
+    end
+
+    def clear_frame_info
+      @frames = nil
+    end
+
+    def stop_reason
+      :breakpoint
+    end
+
+    def ignored?
+      thread.is_a? DebugThread
+    end
+
+    def dead?
+      !@thread.alive?
+    end
+	end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/rbx/frame.rb

@@ -0,0 +1,23 @@
+module Debase
+  class Frame
+    def initialize(location)
+      @location = location
+    end
+
+    def binding
+      @binding ||= Binding.setup(@location.variables, @location.method, @location.constant_scope)
+    end
+
+    def line
+      @location.line
+    end
+
+    def file
+      @location.file
+    end
+
+    def self
+      @location.receiver
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/rbx/monkey.rb

@@ -0,0 +1,13 @@
+class Object
+  # todo: remove me, I'm here only for debugging
+  def method_missing(name, *args)
+    puts "#{self.class}.#{name}"
+    super(name, args)
+  end
+end
+
+module Rubinius
+  class Location
+    attr_reader :receiver
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/rbx.rb

@@ -0,0 +1,102 @@
+require 'debase/rbx/breakpoint'
+require 'debase/rbx/context'
+require 'debase/rbx/monkey'
+
+module Debase
+  class << self
+    attr_reader :breakpoints, :current_context
+
+    def setup_tracepoints
+      return nil unless @catchpoints.nil?
+      @contexts = {}
+      @catchpoints = {}
+      @breakpoints = []
+      Rubinius::CodeLoader.compiled_hook.add proc { |script|
+        @breakpoints.each { | b |
+          if b.source == script.file_path
+            exec, ip = script.compiled_code.locate_line(b.pos)
+            if exec
+              exec.set_breakpoint ip, b
+            end
+          end
+        }
+      }
+      spinup_thread
+      Thread.current.set_debugger_thread @thread
+      self
+    end
+
+    def remove_tracepoints
+    end
+
+    def prepare_context(thread=Thread.current)
+      cleanup_contexts
+      @contexts[thread] ||= Context.new(thread)
+    end
+
+    def cleanup_contexts
+      @contexts.delete_if { |key, _| !key.alive? }
+    end
+
+    def contexts
+      @contexts.values
+    end
+
+    def debug_load(file, stop=false, incremental_start=true)
+      setup_tracepoints
+      prepare_context
+      begin
+        load file
+        nil
+      rescue Exception => e
+        e
+      end
+    end
+
+    def started?
+      !@thread.nil?
+    end
+
+    def listen
+      channel = nil
+      while true
+        channel << true if channel
+        # Wait for someone to stop
+        bp, thread, channel, locs = @local_channel.receive
+
+        if bp
+          context = prepare_context(thread)
+          @current_context = context
+          context.fill_frame_info(locs)
+          context.at_breakpoint(bp)
+          context.at_line(locs.first.file, locs.first.line)
+          puts "resuming execution"
+          context.clear_frame_info
+          @current_context = nil
+        end
+      end
+    end
+
+    def spinup_thread
+      return if @thread
+
+      @local_channel = Rubinius::Channel.new
+
+      @thread = DebugThread.new do
+        begin
+          listen
+        rescue Exception => e
+          puts e
+          e.render("Listening")
+        end
+      end
+
+      @thread.setup_control!(@local_channel)
+    end
+  end
+
+  class DebugThread < Thread
+    def set_debugger_thread
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/debase-0.2.8/lib/debase/version.rb

@@ -0,0 +1,3 @@
+module Debase
+  VERSION = "0.2.8" unless defined? VERSION
+end