Re: Code generation problem with gcc-4.6.1

Re: Code generation problem with gcc-4.6.1

[David Kastrup]

David Kastrup <dak@gnu.org> writes:

P.S.:

> A workaround has been compiling with the options
>
> -fkeep-inline-functions -fno-crossjumping
>
> I don't know which of the two options is responsible for avoiding the
> problem but can test if it makes a difference to you.

It is -fkeep-inline-functions that does the trick.  The generated code
does not generate a _jump_ to Grob::internal_set_property in this case
(for whatever fuzzy reason), but rather a _call_, and with the right
parameters.

Compilation options I forgot to mention are -O2 -fwrapv.  Unfortunately,
an attempt of extracting a toy version of this bug (by taking the
original code and replacing all relevant calls and structures with dummy
declarations in a similar spirit) has not been successful so far, as the
generated code of the toy version is ok even when jumping instead of
calling.

So the problem appears to trigger only under quite specific conditions.

-- 
David Kastrup

Re: Code generation problem with gcc-4.6.1

[David Kastrup]

[-- Attachment #1: Type: text/plain, Size: 1862 bytes --]

David Kastrup <dak@gnu.org> writes:

> David Kastrup <dak@gnu.org> writes:
>
> P.S.:
>
>> A workaround has been compiling with the options
>>
>> -fkeep-inline-functions -fno-crossjumping
>>
>> I don't know which of the two options is responsible for avoiding the
>> problem but can test if it makes a difference to you.
>
> It is -fkeep-inline-functions that does the trick.  The generated code
> does not generate a _jump_ to Grob::internal_set_property in this case
> (for whatever fuzzy reason), but rather a _call_, and with the right
> parameters.
>
> Compilation options I forgot to mention are -O2 -fwrapv.  Unfortunately,
> an attempt of extracting a toy version of this bug (by taking the
> original code and replacing all relevant calls and structures with dummy
> declarations in a similar spirit) has not been successful so far, as the
> generated code of the toy version is ok even when jumping instead of
> calling.
>
> So the problem appears to trigger only under quite specific conditions.

-fwrapv is not necessary, just -O2 is enough.

I append a semi-preprocessed file (I removed all of the system headers
and cut out lots of crap before getting tired) that calls for libguile
as well (including the headers of those would have been too much).

As I said: the code generated for
Tab_staff_symbol_engraver::acknowledge_staff_symbol (Grob_info gi)
is the problem, namely its call to
Grob::internal_set_property
where it confuses the second argument with `this', generating the code:

        movl    %ebx, 40(%esp)
        movl    %ebx, 32(%esp)
        movl    %eax, 36(%esp)
        addl    $24, %esp
        .cfi_remember_state
        .cfi_def_cfa_offset 8
        popl    %ebx
        .cfi_def_cfa_offset 4
        .cfi_restore 3
        jmp     _ZN4Grob21internal_set_propertyEP17scm_unused_structS1_

Can you take it from there?

Thanks


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: junk.cc --]
[-- Type: text/x-c++src, Size: 26138 bytes --]

#include <libguile.h>
#include <string.h>
#include <vector>
#include <math.h>

using namespace std;


#include <algorithm>
#include <climits>
#include <cmath>

using namespace std;

typedef double Real;


template<class T> struct Interval_t;
template<class T> struct PQueue;
template<class T, class A> class Matrix;

typedef Interval_t<Real> Interval;

class Offset;
struct Long_option_init;
class Rational;
class File_name;
class File_path;
class Getopt_long;

typedef unsigned char U8;
typedef short I16;
typedef unsigned short U16;
typedef unsigned U32;
typedef int I32;
typedef unsigned long long U64;




const U64 U64_MAX = (~0ULL);

#include <cassert>

using namespace std;

enum Axis
{
  X_AXIS = 0,
  Y_AXIS = 1,
  NO_AXES = 2,
};

enum Direction
{
  UP = 1,
  DOWN = -1,
  LEFT = -1,
  RIGHT = 1,
  MIN = -1,
  MAX = 1,
  CENTER = 0,
  SMALLER = -1,
  BIGGER = 1,
  START = -1,
  STOP = 1,

  DIRECTION_LIMIT = 2,
  DIRECTION_NEG_LIMIT = -2,
};


template<class T>
struct Drul_array
{
  T array_[2];
  T &at (Direction d)
  {
    (static_cast<void> (0));
    return array_[ (d + 1) / 2];
  }
  T const &at (Direction d) const
  {
    (static_cast<void> (0));
    return array_[ (d + 1) / 2];
  }
  T &operator [] (Direction d)
  {
    return at (d);
  }
  T const &operator [] (Direction d) const
  {
    return at (d);
  }
  Drul_array ()
  {
  }
  Drul_array (T const &t1, T const &t2)
  {
    set (t1, t2);
  }
  void set (T const &t1, T const &t2)
  {
    array_[0] = t1;
    array_[1] = t2;
  }
};




inline SCM
scm_or_str2symbol (char const *c) { return scm_from_locale_symbol (c); }

inline SCM
scm_or_str2symbol (SCM s)
{
  (static_cast<void> (0));
  return s;
}




void add_scm_init_func (void ( *) ());

#include <algorithm>
#include <functional>
#include <cassert>
#include <string>

using namespace std;


typedef size_t vsize;




class All_font_metrics;
class Audio_column;
class Audio_dynamic;
class Audio_element;
class Audio_instrument;
class Audio_item;
class Audio_key;
class Audio_note;
class Audio_piano_pedal;
class Audio_staff;
class Audio_tempo;
class Audio_text;
class Audio_tie;
class Audio_time_signature;
class Auto_change_iterator;
class Auto_change_music;
class Axis_group_engraver;
class Bar_engraver;
class Bar_req_collect_engraver;
class Beaming_pattern;
class Beam_scoring_problem;
class Beam_configuration;
class Beam_quant_parameters;
class Bezier;
class Bezier_bow;
class Book;
class Box;
class Break_algorithm;
class Change_iterator;
class Change_translator;
class Chord_tremolo_iterator;
class Cluster_engraver;
class Column_x_positions;
class Context;
class Context_def;
class Context_mod;
class Context_specced_music;
class Dispatcher;
class Dot_column;
class Dot_configuration;
class Dot_formatting_problem;
class Engraver;
class Engraver;
class Engraver_group;
class Event;
class Event_chord;
class Event_chord_iterator;
class Event_iterator;
class Font_metric;
class Font_size_engraver;
class Global_context;
class Gourlay_breaking;
class Grace_fixup;
class Grace_iterator;
class Grace_music;
class Grob;
class Grob_array;
class Grob_info;
class Hara_kiri_engraver;
class Hara_kiri_line_group_engraver;
class Includable_lexer;
class Input;
class Input_file_results;
class Item;
class Key_performer;
class Keyword_ent;
class Keyword_table;
class Ligature_bracket_engraver;
class Ligature_engraver;
class Lily_lexer;
class Lily_parser;
class Lilypond_context_key;
class Lilypond_grob_key;
class Line_group_engraver_group;
class Listener;
class Lookup;
class Lyric_combine_music;
class Lyric_combine_music_iterator;
class Lyric_engraver;
class Lyric_performer;
class Lyric_phrasing_engraver;
class Mensural_ligature_engraver;
class Midi_chunk;
class Midi_duration;
class Midi_dynamic;
class Midi_event;
class Midi_header;
class Midi_instrument;
class Midi_item;
class Midi_key;
class Midi_note;
class Midi_note_event;
class Midi_note_off;
class Midi_piano_pedal;
class Midi_stream;
class Midi_tempo;
class Midi_text;
class Midi_time_signature;
class Midi_track;
class Modified_font_metric;
class Moment;
class Music;
class Music_iterator;
class Music_list;
class Music_output;
class Music_sequence;
class Music_wrapper;
class Music_wrapper_iterator;
class Note_performer;
class Output_def;
class Open_type_font;
class Output_property;
class Page_breaking;
class Pango_font;
class Paper_book;
class Paper_column;
class Paper_outputter;
class Paper_score;
class Performance;
class Performer;
class Performer_group;
class Piano_bar_engraver;
class Pitch;
class Pitch_squash_engraver;
class Prob;
class Property_iterator;
class Rational;
class Relative_octave_music;
class Repeated_music;
class Scale;
class Scheme_hash_table;
class Scheme_engraver;
class Score;
class Score_context;
class Score_engraver;
class Score_performer;
class Sequential_music;
class Sequential_music_iterator;
class Simple_music_iterator;
class Simple_spacer;
class Simple_spacer_wrapper;
class Simultaneous_music;
class Simultaneous_music_iterator;
class Skyline;
class Skyline_entry;
class Skyline_pair;
class Slur_configuration;
class Slur_score_state;
class Source_file;
class Sources;
class Spacing_options;
class Span_score_bar_engraver;
class Spanner;
class Staff_group_bar_engraver;
class Staff_performer;
class Stencil;
class Stream_event;
class System;
class Tempo_performer;
class Tie;
class Tie_details;
class Tie_configuration;
class Tie_formatting_problem;
class Tie_performer;
class Time_scaled_music;
class Time_scaled_music_iterator;
class Time_signature_performer;
class Timing_engraver;
class Timing_translator;
class Translation_property;
class Translator;
class Translator_change;
class Translator_group;
class Transposed_music;
class yyFlexLexer;

typedef void (*Engraver_void_function_engraver_grob_info) (Engraver *,
                                                           Grob_info);
typedef void (*Translator_void_method_ptr) (Translator *);





class Grob_info
{
  Translator *origin_trans_;
  Grob *grob_;
  Direction start_end_;

  friend class Engraver;
public:
  Direction start_end () const { return start_end_; }
  Grob *grob () const { return grob_; }
  Translator *origin_translator () const { return origin_trans_; }

  Context *context () const;
  Stream_event *event_cause () const;
  Stream_event *ultimate_event_cause () const;
  vector<Context *> origin_contexts (Translator *) const;
  Grob_info (Translator *, Grob *);
  Grob_info ();

  Item *item () const;
  Spanner *spanner () const;
  static bool less (Grob_info i, Grob_info j);







  Context *rerouting_daddy_context_;
};







typedef void (* Global_ctor) ();
void add_constructor (Global_ctor ctor);
void call_constructors ();




#include <typeinfo>


using namespace std;



struct Acknowledge_information
{
  SCM symbol_;
  Engraver_void_function_engraver_grob_info function_;

  Acknowledge_information ()
  {
    symbol_ = ((SCM) ((((4)) << 8) + scm_tc8_flag));
    function_ = 0;
  }
};


typedef struct translator_listener_record
{
  Listener (*get_listener_) (void *, SCM event_class);
  SCM event_class_;
  struct translator_listener_record *next_;

  translator_listener_record ()
  {
    next_ = 0;
    event_class_ = ((SCM) ((((4)) << 8) + scm_tc8_flag));
    get_listener_ = 0;
  }

} translator_listener_record;

enum Translator_precompute_index
{
  START_TRANSLATION_TIMESTEP,
  STOP_TRANSLATION_TIMESTEP,
  PROCESS_MUSIC,
  PROCESS_ACKNOWLEDGED,
  TRANSLATOR_METHOD_PRECOMPUTE_COUNT,
};




class Translator
{
  void init ();

public:
  Context *context () const { return daddy_context_; }

  Translator (Translator const &);

  SCM internal_get_property (SCM symbol) const;

  virtual Output_def *get_output_def () const;
  virtual Translator_group *get_daddy_translator ()const;
  virtual Moment now_mom () const;
  virtual bool must_be_last () const;

  virtual void initialize ();
  virtual void finalize ();


  void connect_to_context (Context *c);
  void disconnect_from_context (Context *c);

  void stop_translation_timestep ();
  void start_translation_timestep ();
  void process_music ();
  void process_acknowledged ();

  Context *get_score_context () const;
  Global_context *get_global_context () const;

  private: public: Translator (); virtual const char *class_name () const { return "Translator"; }; virtual Translator *clone () const { return new Translator (*this); }; static SCM static_description_; virtual void fetch_precomputable_methods (Translator_void_method_ptr methods[]); virtual SCM static_translator_description () const; virtual SCM translator_description () const; static Engraver_void_function_engraver_grob_info static_get_acknowledger (SCM sym); static Engraver_void_function_engraver_grob_info static_get_end_acknowledger(SCM); virtual Engraver_void_function_engraver_grob_info get_acknowledger (SCM sym) { return static_get_acknowledger (sym); } virtual Engraver_void_function_engraver_grob_info get_end_acknowledger (SCM sym) { return static_get_end_acknowledger (sym); } private: static translator_listener_record *listener_list_; public: virtual translator_listener_record *get_listener_list () const { return listener_list_; };
  friend class Non_existent_class; private: static const char* smob_name_; static scm_t_bits smob_tag_; static SCM mark_smob (SCM); static size_t free_smob (SCM s); static int print_smob (SCM s, SCM p, scm_print_state*); public: static SCM equal_p (SCM a, SCM b); static Translator *unsmob (SCM s) __attribute__((pure)) { if ((!(6 & ((scm_t_bits) (0? (*(SCM*)0=(s)): s)))) && ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))))) == smob_tag_) return (Translator *) ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))))); else return 0; } static SCM smob_p (SCM); static void init_smobs (); private: protected: virtual ~Translator (); SCM unprotected_smobify_self (); private: void smobify_self (); SCM self_scm_; SCM protection_cons_; public: SCM unprotect (); void protect (); SCM self_scm () const { return self_scm_; } private:;

protected:
  Context *daddy_context_;
  void protect_event (SCM ev);
  virtual void derived_mark () const;
  static void add_translator_listener (translator_listener_record **listener_list,
                                       translator_listener_record *r,
                                       Listener (*get_listener) (void *, SCM),
                                       const char *ev_class);
  SCM static_translator_description (const char *grobs,
                                     const char *desc,
                                     translator_listener_record *listener_list,
                                     const char *read,
                                     const char *write) const;

  friend class Translator_group;
};

void add_translator (Translator *trans);

Translator *get_translator (SCM s);



class Engraver : public Translator
{
  Grob *internal_make_grob (SCM sym, SCM cause, char const *name,
                            char const *f, int l, char const *fun);
  friend SCM ly_engraver_make_grob (SCM, SCM, SCM);
  friend class Engraver_group;
protected:






  virtual void acknowledge_grob (Grob_info) {}
  virtual void announce_grob (Grob_info);
  virtual void announce_end_grob (Grob_info);
  Engraver_group *get_daddy_engraver () const;

public:



  void announce_grob (Grob *, SCM cause);
  void announce_end_grob (Grob *, SCM cause);

  Grob_info make_grob_info (Grob *, SCM cause);

  Item *internal_make_item (SCM sym, SCM cause, char const *name,
                            char const *f, int l, char const *fun);
  Spanner *internal_make_spanner (SCM sym, SCM cause, char const *name,
                                  char const *f, int l, char const *fun);
  Paper_column *internal_make_column (SCM sym, char const *name,
                                      char const *f, int l, char const *fun);




  private: public: Engraver (); virtual const char *class_name () const { return "Engraver"; }; virtual Translator *clone () const { return new Engraver (*this); }; static SCM static_description_; static Drul_array<vector<Acknowledge_information> > acknowledge_static_array_drul_; virtual void fetch_precomputable_methods (Translator_void_method_ptr methods[]); virtual SCM static_translator_description () const; virtual SCM translator_description () const; static Engraver_void_function_engraver_grob_info static_get_acknowledger (SCM sym); static Engraver_void_function_engraver_grob_info static_get_end_acknowledger(SCM); virtual Engraver_void_function_engraver_grob_info get_acknowledger (SCM sym) { return static_get_acknowledger (sym); } virtual Engraver_void_function_engraver_grob_info get_end_acknowledger (SCM sym) { return static_get_end_acknowledger (sym); } private: static translator_listener_record *listener_list_; public: virtual translator_listener_record *get_listener_list () const { return listener_list_; };
};





Engraver *unsmob_engraver (SCM eng);
bool ly_is_grob_cause (SCM obj);

SCM add_interface (char const *cxx_name,
                   char const *descr,
                   char const *vars);

SCM ly_add_interface (SCM, SCM, SCM);
void internal_add_interface (SCM, SCM, SCM);
SCM ly_all_grob_interfaces ();


class Grob
{
private:
  friend class Non_existent_class; private: static const char* smob_name_; static scm_t_bits smob_tag_; static SCM mark_smob (SCM); static size_t free_smob (SCM s); static int print_smob (SCM s, SCM p, scm_print_state*); public: static SCM equal_p (SCM a, SCM b); static Grob *unsmob (SCM s) __attribute__((pure)) { if ((!(6 & ((scm_t_bits) (0? (*(SCM*)0=(s)): s)))) && ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))))) == smob_tag_) return (Grob *) ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))))); else return 0; } static SCM smob_p (SCM); static void init_smobs (); private: protected: virtual ~Grob (); SCM unprotected_smobify_self (); private: void smobify_self (); SCM self_scm_; SCM protection_cons_; public: SCM unprotect (); void protect (); SCM self_scm () const { return self_scm_; } private:;
  virtual const char *class_name () const { return "Grob"; };

  void init ();

protected:

  Output_def *layout_;
  Grob *original_;


  SCM immutable_property_alist_;
  SCM mutable_property_alist_;
  SCM object_alist_;





  SCM interfaces_;

  void substitute_object_links (SCM, SCM);
  Real get_offset (Axis a) const;
  SCM try_callback (SCM, SCM);
  SCM try_callback_on_alist (SCM *, SCM, SCM);
  void internal_set_value_on_alist (SCM *alist, SCM sym, SCM val);

public:


  friend class Spanner;
  friend class System;
  friend SCM ly_grob_properties (SCM);
  friend SCM ly_grob_basic_properties (SCM);


  static SCM x_parent_positioning (SCM); static SCM x_parent_positioning_proc;
  static SCM y_parent_positioning (SCM); static SCM y_parent_positioning_proc;
  static SCM stencil_height (SCM smob); static SCM stencil_height_proc;
  static SCM stencil_width (SCM smob); static SCM stencil_width_proc;


  Output_def *layout () const { return layout_; }
  Grob *original () const { return original_; }
  SCM interfaces () const { return interfaces_; }


  Grob (SCM basic_props);
  Grob (Grob const &);
  virtual Grob *clone () const;


  void suicide ();
  bool is_live () const;


  string name () const;


  SCM get_property_alist_chain (SCM) const;
  SCM internal_get_property (SCM symbol) const;
  SCM internal_get_property_data (SCM symbol) const;
  SCM internal_get_pure_property (SCM symbol, int start, int end) const;
  SCM internal_get_maybe_pure_property (SCM symbol, bool pure, int start, int end) const;
  SCM internal_get_non_callback_marker_property_data (SCM symbol) const;
  SCM internal_get_object (SCM symbol) const;
  void internal_set_object (SCM sym, SCM val);
  void internal_del_property (SCM symbol);
  void instrumented_set_property (SCM, SCM, char const *, int, char const *);
  void internal_set_property (SCM sym, SCM val);


  void warning (string) const;
  void programming_error (string) const;


  virtual System *get_system () const;
  static System *get_system (Grob *);
  virtual void do_break_processing ();
  virtual Grob *find_broken_piece (System *) const;
  virtual void discretionary_processing ();
  virtual void derived_mark () const;
  virtual void handle_broken_dependencies ();
  virtual void handle_prebroken_dependencies ();


  Stencil *get_stencil () const;
  Stencil get_print_stencil () const;


  bool internal_has_interface (SCM intf);
  static SCM interface_symbol_; static bool has_interface (Grob*);


  void translate_axis (Real, Axis);
  Real relative_coordinate (Grob const *refp, Axis) const;
  Real pure_relative_y_coordinate (Grob const *refp, int start, int end);
  Real maybe_pure_coordinate (Grob const *refp, Axis a, bool pure, int start, int end);


  Interval extent (Grob *refpoint, Axis) const;
  void flush_extent_cache (Axis);
  virtual Interval pure_height (Grob *refpoint, int start_col, int end_col);
  Interval maybe_pure_extent (Grob *refpoint, Axis, bool pure, int start, int end);


  Grob *common_refpoint (Grob const *s, Axis a) const;
  void set_parent (Grob *e, Axis);
  Grob *get_parent (Axis a) const;
  void fixup_refpoint ();


  static Grob *get_root_vertical_alignment (Grob *g);
  static Grob *get_vertical_axis_group (Grob *g);
  static bool vertical_less (Grob *g1, Grob *g2);
  static bool pure_vertical_less (Grob *g1, Grob *g2);
  static bool internal_vertical_less (Grob *g1, Grob *g2, bool pure);
  static int get_vertical_axis_group_index (Grob *g);

  virtual Interval_t<int> spanned_rank_interval () const;
  virtual bool pure_is_visible (int start, int end) const;
  bool check_cross_staff (Grob *common);
  static bool less (Grob *g1, Grob *g2);
};





class Tab_staff_symbol_engraver : public Engraver
{
public:
  private: public: Tab_staff_symbol_engraver (); virtual const char *class_name () const { return "Tab_staff_symbol_engraver"; }; virtual Translator *clone () const { return new Tab_staff_symbol_engraver (*this); }; static SCM static_description_; static Drul_array<vector<Acknowledge_information> > acknowledge_static_array_drul_; virtual void fetch_precomputable_methods (Translator_void_method_ptr methods[]); virtual SCM static_translator_description () const; virtual SCM translator_description () const; static Engraver_void_function_engraver_grob_info static_get_acknowledger (SCM sym); static Engraver_void_function_engraver_grob_info static_get_end_acknowledger(SCM); virtual Engraver_void_function_engraver_grob_info get_acknowledger (SCM sym) { return static_get_acknowledger (sym); } virtual Engraver_void_function_engraver_grob_info get_end_acknowledger (SCM sym) { return static_get_end_acknowledger (sym); } private: static translator_listener_record *listener_list_; public: virtual translator_listener_record *get_listener_list () const { return listener_list_; };
protected:
  public : void acknowledge_staff_symbol (Grob_info); protected:;
};

void
Tab_staff_symbol_engraver::acknowledge_staff_symbol (Grob_info gi)
{
  int k = scm_ilength (internal_get_property (({ static SCM cached; SCM value = cached; if (__builtin_constant_p (("stringTunings"))) { if (!cached) value = cached = scm_gc_protect_object (scm_or_str2symbol ("stringTunings")); } else value = scm_or_str2symbol ("stringTunings"); value; })));
  if (k >= 0)
    gi.grob ()->internal_set_property (({ static SCM cached; SCM value = cached; if (__builtin_constant_p (("line-count"))) { if (!cached) value = cached = scm_gc_protect_object (scm_or_str2symbol ("line-count")); } else value = scm_or_str2symbol ("line-count"); value; }), scm_from_int32 (k));
}

Tab_staff_symbol_engraver::Tab_staff_symbol_engraver ()
{
}








typedef struct
{
  void (*listen_callback) (void *, SCM);
  void (*mark_callback) (void *);
} Listener_function_table;

class Listener
{
  void *target_;
  Listener_function_table *type_;
public:
  Listener (const void *target, Listener_function_table *type);
  Listener (Listener const &other);
  Listener ();

  void listen (SCM ev) const;

  bool operator == (Listener const &other) const
  { return target_ == other.target_ && type_ == other.type_; }

  public: SCM smobbed_copy () const; friend class Non_existent_class; private: static const char* smob_name_; static scm_t_bits smob_tag_; static SCM mark_smob (SCM); static size_t free_smob (SCM s); static int print_smob (SCM s, SCM p, scm_print_state*); public: static SCM equal_p (SCM a, SCM b); static Listener *unsmob (SCM s) __attribute__((pure)) { if ((!(6 & ((scm_t_bits) (0? (*(SCM*)0=(s)): s)))) && ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((0))]))))) == smob_tag_) return (Listener *) ((((scm_t_bits) (0? (*(SCM*)0=((((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))): (((SCM *)((scm_t_cell *) (((scm_t_bits) (0? (*(SCM*)0=((((s))))): (((s)))))))) [((1))]))))); else return 0; } static SCM smob_p (SCM); static void init_smobs (); private:;
};
inline Listener * unsmob_listener (SCM s) { return Listener::unsmob (s); };


void add_acknowledger (Engraver_void_function_engraver_grob_info ptr,
                       char const *func_name,
                       vector<Acknowledge_information> *ack_array);

Engraver_void_function_engraver_grob_info
generic_get_acknowledger (SCM sym,
                          vector<Acknowledge_information> const *ack_array);


void Tab_staff_symbol_engraverstaff_symbol_ack_adder () { add_acknowledger ((Engraver_void_function_engraver_grob_info) & Tab_staff_symbol_engraver::acknowledge_staff_symbol, "staff_symbol", &Tab_staff_symbol_engraver::acknowledge_static_array_drul_[START]); } class Tab_staff_symbol_engraverstaff_symbol_ack_adder_initclass_scm_initter { public: Tab_staff_symbol_engraverstaff_symbol_ack_adder_initclass_scm_initter () { add_scm_init_func (Tab_staff_symbol_engraverstaff_symbol_ack_adder); } } _Tab_staff_symbol_engraverstaff_symbol_ack_adder_initclass_scm_initter;;;
void Tab_staff_symbol_engraver::fetch_precomputable_methods (Translator_void_method_ptr ptrs[]) { ptrs[START_TRANSLATION_TIMESTEP] = ((Translator_void_method_ptr) & Tab_staff_symbol_engraver::start_translation_timestep == (Translator_void_method_ptr) & Translator::start_translation_timestep) ? 0 : (Translator_void_method_ptr) & Tab_staff_symbol_engraver::start_translation_timestep; ptrs[STOP_TRANSLATION_TIMESTEP] = ((Translator_void_method_ptr) & Tab_staff_symbol_engraver::stop_translation_timestep == (Translator_void_method_ptr) & Translator::stop_translation_timestep) ? 0 : (Translator_void_method_ptr) & Tab_staff_symbol_engraver::stop_translation_timestep; ptrs[PROCESS_MUSIC] = ((Translator_void_method_ptr) & Tab_staff_symbol_engraver::process_music == (Translator_void_method_ptr) & Translator::process_music) ? 0 : (Translator_void_method_ptr) & Tab_staff_symbol_engraver::process_music; ptrs[PROCESS_ACKNOWLEDGED] = ((Translator_void_method_ptr) & Tab_staff_symbol_engraver::process_acknowledged == (Translator_void_method_ptr) & Translator::process_acknowledged) ? 0 : (Translator_void_method_ptr) & Tab_staff_symbol_engraver::process_acknowledged; }; SCM Tab_staff_symbol_engraver::static_description_ = ((SCM) ((((4)) << 8) + scm_tc8_flag)); static void

 _Tab_staff_symbol_engraver_adder

 () { Tab_staff_symbol_engraver *t = new Tab_staff_symbol_engraver; Tab_staff_symbol_engraver::static_description_ = t->static_translator_description (); scm_permanent_object (Tab_staff_symbol_engraver::static_description_); add_translator (t); } SCM Tab_staff_symbol_engraver::translator_description () const { return static_description_; } class

 Global_ctor__Tab_staff_symbol_engraver_adder

 { public:

 Global_ctor__Tab_staff_symbol_engraver_adder

 () { add_constructor (_Tab_staff_symbol_engraver_adder); } }

 __Tab_staff_symbol_engraver_adder_ctor_init

 ;;;; SCM Tab_staff_symbol_engraver::static_translator_description () const { return Translator::static_translator_description ("StaffSymbol ", "Create a tablature staff symbol, but look at" " @code{stringTunings} for the number of lines.", listener_list_, "stringTunings ", ""); } Drul_array< vector<Acknowledge_information> > Tab_staff_symbol_engraver::acknowledge_static_array_drul_; Engraver_void_function_engraver_grob_info Tab_staff_symbol_engraver::static_get_acknowledger (SCM sym) { return generic_get_acknowledger (sym, &acknowledge_static_array_drul_[START]); } Engraver_void_function_engraver_grob_info Tab_staff_symbol_engraver::static_get_end_acknowledger (SCM sym) { return generic_get_acknowledger (sym, &acknowledge_static_array_drul_[STOP]); } translator_listener_record *Tab_staff_symbol_engraver::listener_list_;

                ;

[-- Attachment #3: Type: text/plain, Size: 19 bytes --]


-- 
David Kastrup