#include "parser.h"



namespace   parser
{
    struct  function_param_value_t    : misc_t
    {
        function_param_value_t() : virtua( NULL), virtual_type( NULL), expression( NULL), comma( NULL) {}
        virtual void    output( outstream_t& out)   const;
        
        keyword_virtual*            virtua;    // used for caller-dispatch.
        parser::declarator_left_t*  virtual_type;   // used for caller-dispatch.
        expression_t*               expression;
        keyword_COMMA*              comma;  // NULL iff last parameter.
    };

    struct  function_param_values_t   : misc_t
    {
        function_param_values_t() : open( NULL), params(), num_virtual_params( 0), close( NULL) {}
        virtual void    output( outstream_t& out)   const;
        
        typedef std::vector< function_param_value_t*> params_t;
        
        keyword_OPENROUND*  open;
        params_t            params;
        int                 num_virtual_params;
        keyword_CLOSEROUND* close;
    };
    
    struct  named_functioncall_expression_t : expression_t
    {
        named_functioncall_expression_t() : name( NULL), params( NULL) {}
        
        static const char*  static_description()    { return "nameexpression";  }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        name_t*                     name;
        function_param_values_t*    params;
    };
    struct  name_expression_t  : expression_t
    {
        name_expression_t() : name() {}
        static const char*  static_description()    { return "nameexpression";  }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        name_t* name;
    };

    struct  typename_expression_t  : expression_t
    {
        static const char*  static_description()    { return "typenameexpression";  }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        typename_expression_t() : type() {}
        node_t* type;
    };

    struct  numerical_expression_t : expression_t
    {
        numerical_expression_t() : number() {}
        static const char*  static_description()    { return "numerical expression";    }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        number_t*   number;
    };

    struct  expression_t;

    struct  bracket_expression_t   : expression_t
    {
        bracket_expression_t() : open( NULL), expression( NULL), close( NULL) {}
        static const char*  static_description()    { return "bracketexpression";   }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        keyword_OPENROUND*  open;
        expression_t*       expression;
        keyword_CLOSEROUND* close;
    };

    struct  expression_list_item_t  : simplenode_t
    {
        expression_list_item_t() : preop( NULL), expression( NULL) {}
        static const char*  static_description()    { return "expresion2item";  }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;

        node_t*         preop;  // null if first item in expression has no prefix op.
        expression_t*   expression; // can be null if last item in expression is a postfix op.
    };

    struct  expression_list_t   : expression_t
    {
        expression_list_t() : items() {}
        static const char*  static_description()    { return "expression2list"; }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        typedef std::vector< expression_list_item_t*>   items_t;
        
        items_t items;
    };

    struct  expression_terminator_t : simplenode_t
    {
        expression_terminator_t() : expr( NULL), semicolon( NULL) {}
        static const char*  static_description()    { return "expression2list `;'"; }
        virtual const char* description()   const   { return static_description();  }
        virtual void        output( outstream_t& out)   const;
        
        expression_t*   expr;
        keyword_SEMICOLON*  semicolon;

    };

    for_loop_initstatement_t*   get_for_loop_initstatement( lexer_t& lexer, context_t& context);
    expression_t*               tryget_expression( lexer_t& lexer, context_t& context);
    expression_terminator_t*    tryget_terminated_expression( lexer_t& lexer, context_t& context);
    expression_t*               get_expression( lexer_t& lexer, context_t& context);
    node_t*                     get_if_expression( lexer_t& lexer, context_t& context);
    void                        ensure_parameter_names( function_parameters_t*& fnparams0);
    declarator_name_t*          make_function_pointer( const char* pointername, function_t* function);
}