reflex.cpp.targetspec

// ///////////////////////////////////////////////////////////////////////////
// reflex.cpp.targetspec by Victor Dods, created 2006/11/09
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

// This is a reflex targetspec file for a C++ lexical scanner class using a
// deterministic finite automaton (DFA).
%target cpp

// The value of this directive specifies the filename to use when generating
// the header file (it is used by the below add_codespec directive).
%add_required_directive header_filename %string
// This refers to the file reflex.cpp.header.codespec in the data directory.
// See that file for the header template code.
%add_codespec "header" header_filename

// The value of this directive specifies the filename to use when generating
// the implementation file (it is used by the below add_codespec directive).
%add_required_directive implementation_filename %string
// This refers to the file reflex.cpp.implementation.codespec in the data
// directory.  See that file for the implementation template code.
%add_codespec "implementation" implementation_filename

// ///////////////////////////////////////////////////////////////////////////
// The following directives can be thought of as applying to the header file
// which is to be generated by reflex.
// ///////////////////////////////////////////////////////////////////////////

// The value of this directive will be placed at the top of the generated
// header file, below the generated #include directives.  It is a dumb code
// block (as opposed to a strict code block) so that you can open a namespace
// which the generated class will be enclosed in (and consequently, the
// matching close-bracket is not in the same code block).
// e.g. %{ namespace SweetNamespace { %}
%add_optional_directive top_of_header_file                  %dumb_code_block
// The name of the class to be generated by reflex, e.g. "DumbScanner"
%add_required_directive class_name                          %identifier
// The optional class inheritance of the generated class,
// e.g. { public AwesomeBase }
%add_optional_directive class_inheritance                   %strict_code_block
// Class declarations to put at the top of the generated class.  They will by
// default have class access of public.  This may be necessary to use in some
// cases to guarantee that these declarations come before later ones
// (including the scanner's generated methods.
// e.g. { enum HippoType { HAPPY, SAD, ANGRY }; }
%add_optional_directive top_of_class                        %strict_code_block
// Specifies the parameters for both the declaration and the definition of the
// generated class' constructor, unless constructor_definition_parameters is
// also specified, in which case, this one is only used for the constructor's
// declaration (i.e. the one which appears in the header file).
// e.g. "HippoType best_hippo_type = ANGRY"
%add_optional_directive constructor_parameters              %strict_code_block
// Specifies the parameters for the definition of the generated class'
// constructor (i.e. the one which appears in the implementation file),
// overriding constructor_parameters.  It is an error to specify a value
// for this directive without specifying a value for constructor_parameters.
// e.g. "HippoType best_hippo_type"
%add_optional_directive constructor_definition_parameters   %strict_code_block
// When present, causes the generated class' destructor to be virtual.
%add_optional_directive force_virtual_destructor
// Specifies the class access of the generated Scan method.  Valid values are
// "public:", "protected:" or "private:".  The default access is "public:".
%add_optional_directive scan_method_access                  %string
// Specifies the parameters for the declaration and the definition of the
// generated Scan method, unless scan_method_definition_parameters is also
// specified, in which case, this one is only used for the Scan method's
// declaration (i.e. the one which appears in the header file).  These
// parameters will be available to all regex rule handlers specified in the
// reflex source file.
// e.g. "AstBase *dest_token, HippoType hippo_type = HAPPY"
%add_optional_directive scan_method_parameters              %strict_code_block
// Specifies the parameters for the definition of the generated Scan method
// (i.e. the one which appears in the implementation file).  It is an error to
// specify a value for this directive without specifying a value for
// scan_method_parameters. These parameters will be available to all regex
// rule handlers specified in the reflex source file.
// e.g. "AstBase *dest_token, HippoType hippo_type"
%add_optional_directive scan_method_definition_parameters   %strict_code_block
// Similar to top_of_class, this facilitates class declarations at the bottom,
// which may be necessary when declarations from the middle of the generated
// class are needed.  Again, the default class access level is public.
// e.g. { Mode::Name m_saved_scanner_mode; }
%add_optional_directive bottom_of_class                     %strict_code_block
// This is the analog to top_of_header_file -- its contents go directly at the
// bottom of the generated header file.  If you opened a namespace from within
// top_of_header_file, remember to close it here.
// e.g. %{ } // end of namespace SweetNamespace %}
%add_optional_directive bottom_of_header_file               %dumb_code_block

// ///////////////////////////////////////////////////////////////////////////
// The following directives can be thought of as applying to the
// implementation file which is to be generated by reflex.
// ///////////////////////////////////////////////////////////////////////////

// Like top_of_header_file, the value of this directive will be placed at the
// top of the generated implementation file, below the generated #include
// directives.  It is also a dumb code block, so you can employ unterminated
// namespace blocks.
// e.g. %{ namespace SweetNamespace { %}
%add_optional_directive top_of_implementation_file          %dumb_code_block
// If any superclasses or members need explicit construction, do it here.
// e.g. { AwesomeBase(1, 2, 3), m_saved_scanner_mode(Mode::MAIN) }
%add_optional_directive superclass_and_member_constructors  %strict_code_block
// This specifies code for the body of the generated class' constructor.
// e.g. { std::cout << "constructor being executed" << std::endl; }
%add_optional_directive constructor_actions                 %strict_code_block
// Like constructor_actions, this specifies code for the body of the generated
// class' destructor.
// e.g. { std::cout << "destructor being executed" << std::endl; }
%add_optional_directive destructor_actions                  %strict_code_block
// If anything needs to be done at the very beginning of the generated Scan
// method, it should be specified here.  If you wanted to enclose the entire
// contents of the Scan method within a "try" block, you would use this to
// open the "try" block.
// e.g. %{ try { %}
%add_optional_directive start_of_scan_method_actions        %dumb_code_block
// This is the analog to start_of_scan_method_actions -- its contents go
// directly at the end of the generated Scan method.  If you opened a "try"
// block within start_of_scan_method_actions, remember to finish it with one
// or more "catch" blocks.  This section of the Scan method will only be
// reached if no scanner regex rules or rejection_actions (see below) return
// upon end-of-file.  If you specify a non-void value for return_type, you
// should remember to provide a return statement (your C++ compiler should
// warn about this if left out).
// e.g. %{ } catch (...) { std::cout << "caught exception" << std::endl } %}
%add_optional_directive end_of_scan_method_actions          %dumb_code_block
// This is the analog to top_of_implementation_file -- its contents go
// directly at the bottom of the generated implementation file.  If you opened
// a namespace from within top_of_implementation_file, remember to close it
// here.
// e.g. %{ } // end of namespace SweetNamespace %}
%add_optional_directive bottom_of_implementation_file       %dumb_code_block

// ///////////////////////////////////////////////////////////////////////////
// The following directives can be thought of as I/O parameters for the
// scanner class which is to be generated by reflex.
// ///////////////////////////////////////////////////////////////////////////

// This specifies the return type of the generated Scan method.  The default
// value is void so as to not require a return statement in the Scan method.
// e.g. use "TrisonParserClass::Token::Type" -- when reflex is used with
// trison.
%add_optional_directive return_type                         %string             %default "void"
// This value's code should return true only when the next read operation will
// produce the end-of-file condition.  The default value is an example for
// indicating EOF for stdin.
%add_optional_directive return_true_iff_input_is_at_end     %strict_code_block  %default { return std::cin.peek() == std::char_traits<char>::eof(); }
// This value's code should return the next input character.  The null char
// '\0' should not be returned by this code; correspondingly, this code will
// never be called once the end-of-file condition has been reached.  The
// default value is an example for returning the next character from stdin.
%add_optional_directive return_next_input_char              %strict_code_block  %default { return std::cin.get(); }
// This value's code is executed when a character is not matched by any regex
// rule in the scanner's current state.  The rejected character is in the
// local variable rejected_atom.  This is never called at the end of input;
// the main scanner loop is broken from and end_of_scan_method_actions is
// executed.  The default value simply prints the unmatched char to stdout.
%add_optional_directive rejection_actions                   %strict_code_block  %default { std::cout << rejected_atom; }
// This specifies code to be executed when the scanner object is being reset
// to start scanning from a new source.  This code is executed in addition to
// various internal state-machine-related initialization that is required.
%add_optional_directive reset_for_new_input_actions         %strict_code_block

// ///////////////////////////////////////////////////////////////////////////
// Miscellaneous directives
// ///////////////////////////////////////////////////////////////////////////

// When present, indicates that the code associated with debug spew will be
// generated; the methods Get/SetDebugSpewFlags will be generated.
%add_optional_directive generate_debug_spew_code
// When present, will prevent the timestamp from being added to the top of
// the generated source code files (useful when the generated files are
// checked into a version control system).  The default behavior is to 
// put a timestamp in the generated header and implementation files.
%add_optional_directive dont_generate_timestamps


// TODO: add BARF-developer debug code directive

---