/*
=====================================================================
                        Source: report.rule
=====================================================================
*/


start_cmd : 
	START_REPORT rep_name atline  TO_PRINTER  op_with_dim {
			struct expr_str *p;
			$<startrep>$=$<startrep>5;
			$<startrep>$->towhat='|';
			set_cmdlineno($<integer_val>3);

			p=A4GL_new_expr_simple(ET_EXPR_REPORT_PRINTER);

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<startrep>$->s1=chk_expr(p);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);

			}
	| START_REPORT rep_name atline  TO_EMAIL  op_with_dim {
			struct expr_str *p;
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>5;
			$<startrep>$->towhat='M';
			p=A4GL_new_expr_email_report($<str>2,NULL); 
			$<startrep>$->s1=chk_expr(p);
			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);

			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	| START_REPORT rep_name atline  TO_EMAIL fgl_expr_c op_with_dim {
			struct expr_str *p;
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>6;
			$<startrep>$->towhat='M';
			p=A4GL_new_expr_email_report($<str>2,$<ptr>5); 
			$<startrep>$->s1=chk_expr(p);
			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);

			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  KW_TO rout op_with_dim {
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>6;
			$<startrep>$->towhat='F';
			$<startrep>$->s1=chk_expr($<ptr>5);

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  TO_FILE rout op_with_dim {
			set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>6;
			$<startrep>$->towhat='F';
			$<startrep>$->s1=chk_expr($<ptr>5);

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  TO_PIPE rout op_with_dim {
			set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>6;
			$<startrep>$->towhat='|';
			$<startrep>$->s1=chk_expr($<ptr>5);

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  TO_UI  op_with_dim {
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>5;
			$<startrep>$->towhat='U';
			$<startrep>$->s1=chk_expr( A4GL_new_expr_simple_string($<str>2,ET_EXPR_REPORT_UI));

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  TO_SCREEN op_with_dim {
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>5;
			$<startrep>$->towhat='S';
			$<startrep>$->s1=0;

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);
			}
	    | START_REPORT rep_name atline  AS_CONVERTIBLE  op_with_dim {
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>5;
			$<startrep>$->towhat='C';
			$<startrep>$->s1=0;

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);
			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);

			}
	    | START_REPORT rep_name  atline  op_with_dim {
		set_cmdlineno($<integer_val>3);
			$<startrep>$=$<startrep>4;
			$<startrep>$->towhat=0;
			$<startrep>$->s1=0;

			add_feature("USE_REPORT");
			ADDMAP("Start Report",$<str>2);
			map_start_report($<str>2);

			$<cmd>$=new_start_cmd($<str>2, $<startrep>$);

			}
;

op_with_dim:
	{
			$<startrep>$=malloc(sizeof(startrep));
			$<startrep>$->with_page_length=-1;
			/*$<startrep>$->with_page_width=-1; */
			$<startrep>$->with_left_margin=-1; 
			$<startrep>$->with_right_margin= -1;
			$<startrep>$->with_top_margin= -1;
			$<startrep>$->with_bottom_margin= -1;
			$<startrep>$->with_top_of_page= strdup("");
			with_page_length=-1;
			/* with_page_width=-1; */
			with_left_margin=-1;
			with_right_margin=-1;
			with_top_margin=-1;
			with_bottom_margin=-1;
			with_top_of_page="";
	}
	| WITH with_list {
			$<startrep>$=malloc(sizeof(startrep));
			$<startrep>$->with_page_length=with_page_length;
			/*$<startrep>$->with_page_width=with_page_width; */
			$<startrep>$->with_left_margin= with_left_margin;
			$<startrep>$->with_right_margin= with_right_margin;
			$<startrep>$->with_top_margin= with_top_margin;
			$<startrep>$->with_bottom_margin= with_bottom_margin;
			$<startrep>$->with_top_of_page= strdup(with_top_of_page);

			with_page_length=-1;
			/*with_page_width=-1; */
			with_left_margin=-1;
			with_right_margin=-1;
			with_top_margin=-1;
			with_bottom_margin=-1;
			with_top_of_page="";
	}
;


op_comma: 
	| KW_COMMA
;

with_list:
	with_entry
	| with_list op_comma with_entry
;

with_entry:
	PAGE_LENGTH op_equal INT_VALUE {with_page_length=atoi($<str>3);}
	| TOP_MARGIN op_equal INT_VALUE {with_top_margin=atoi($<str>3);}
	| BOTTOM_MARGIN op_equal INT_VALUE {with_bottom_margin=atoi($<str>3);}
	| LEFT_MARGIN op_equal INT_VALUE {with_left_margin=atoi($<str>3);}
	| RIGHT_MARGIN op_equal INT_VALUE {with_right_margin=atoi($<str>3);}
	| TOP_OF_PAGE op_equal CHAR_VALUE {with_top_of_page=acl_strdup($<str>3);}

	| PAGE_LENGTH OPEN_BRACKET INT_VALUE CLOSE_BRACKET {with_page_length=atoi($<str>2);}
	| TOP_MARGIN OPEN_BRACKET INT_VALUE CLOSE_BRACKET {with_top_margin=atoi($<str>2);}
	| BOTTOM_MARGIN OPEN_BRACKET INT_VALUE CLOSE_BRACKET {with_bottom_margin=atoi($<str>2);}
	| LEFT_MARGIN OPEN_BRACKET INT_VALUE CLOSE_BRACKET {with_left_margin=atoi($<str>2);}
	| RIGHT_MARGIN OPEN_BRACKET INT_VALUE CLOSE_BRACKET {with_right_margin=atoi($<str>2);}
	| TOP_OF_PAGE OPEN_BRACKET CHAR_VALUE CLOSE_BRACKET {with_top_of_page=acl_strdup($<str>2);}
;
	

conv_rep_conv:  { $<convert>$=0; }
	| KW_TO char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->emailAddress=0;
		$<convert>$->conv_type=$<ptr>4;
	}
	|  VIA via_functionname {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='f';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->conv_type=0;
		$<convert>$->emailAddress=0;
	}
	| TO_PIPE char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='|';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->emailAddress=0;
	}
	| TO_PRINTER KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='P';
		$<convert>$->conv_type=$<ptr>2;
		$<convert>$->s1=0;
		$<convert>$->filter=0;
		$<convert>$->emailAddress=0;
	}
	| TO_EMAIL KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->conv_type=$<ptr>3;
		$<convert>$->s1=0;
		$<convert>$->filter=0;
		$<convert>$->emailAddress=0;
	}
	| TO_EMAIL char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->s1=0;
		$<convert>$->filter=0;
		$<convert>$->emailAddress=$<ptr>2;
	}
	| TO_FILE char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=0;
		$<convert>$->emailAddress=0;
	}
	| KW_TO char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=$<ptr>6;
		$<convert>$->emailAddress=0;
	}
	| TO_FILE char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=$<ptr>6;
		$<convert>$->emailAddress=0;

	}
	| TO_PIPE char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='|';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=$<ptr>6;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->emailAddress=0;
	}
	| TO_PRINTER KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='P';
		$<convert>$->s1=0;
		$<convert>$->filter=$<ptr>5;
		$<convert>$->conv_type=$<ptr>3;
		$<convert>$->emailAddress=0;
	}
	| TO_EMAIL KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->s1=0;
		$<convert>$->filter=$<ptr>5;
		$<convert>$->conv_type=$<ptr>3;
		$<convert>$->emailAddress=0;
	}
	| TO_EMAIL char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->s1=0;
		$<convert>$->filter=$<ptr>6;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->emailAddress=$<ptr>2;
	}
;

convert_cmd : 	CONVERT_REPORT rep_name conv_rep_conv {
			$<cmd>$=new_convert_cmd($<str>2, $<convert>3);
		}
;

via_functionname: identifier {
		char buff[256];
		SPRINTF2(buff,"%s%s", get_namespace($<str>1),$<str>1);
		$<ptr>$=A4GL_new_literal_string(buff);
	}
;

rout : fgl_expr_c {
		$<ptr>$=$<ptr>1;
	}
;


free_rep_cmd : FREE_REPORT rep_name {
		$<cmd>$=new_free_rep_cmd($<str>2);
}
;

rep_name : identifier;


op_values : | VALUES ; /* This isn't standard - but it looks pretty OUTPUT TO REPORT VALUES (...)... */


op_fgl_expr_list_ptr:  {$<ptr_list>$=0;}
	| fgl_expr_list_ptr  {$<ptr_list>$=$<ptr_list>1;}
;


output_cmd : OUTPUT_TO_REPORT atline rep_name op_values  OPEN_BRACKET op_fgl_expr_list_ptr CLOSE_BRACKET {
		struct expr_str_list *l;	
		set_cmdlineno($<integer_val>2);
		l=expand_variables_in_expr_str_list($<ptr_list>6,0,1);
		$<cmd>$=new_output_cmd($<str>3,l);
		add_feature("USE_REPORT");
		output_to_report_definition($<str>3, l);
		ADDMAP("Output to report",$<str>3);
		}
;

finish_cmd : FINISH_REPORT atline rep_name rep_conv {
		set_cmdlineno($<integer_val>2);
		ADDMAP("Finish Report",$<str>3);
		add_feature("USE_REPORT");
		$<cmd>$=new_finish_cmd($<str>3,$<convert>4);
		}
;


rep_conv:  { $<convert>$=0; }
	|  CONVERTING_TO_MANY   {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='M';
		$<convert>$->s1=0;
		$<convert>$->conv_type=0;
		$<convert>$->filter=0;
	}
	| CONVERTING_TO char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->conv_type=$<ptr>4;
	}
	|  CONVERTING_VIA via_functionname {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='f';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->conv_type=0;
	}
	| CONVERTING_TO_PIPE char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='|';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=0;
		$<convert>$->conv_type=$<ptr>4;
	}
	| CONVERTING_TO_PRINTER KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='P';
		$<convert>$->conv_type=$<ptr>3;
		$<convert>$->s1=0;
		$<convert>$->filter=0;
	}
	| CONVERTING_TO_EMAIL KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->conv_type=$<ptr>3;
		$<convert>$->s1=0;
		$<convert>$->filter=0;
	}
	| CONVERTING_TO_FILE char_or_var_vl KW_AS char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=0;
	}
	| CONVERTING_TO char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=$<ptr>6;
	}
	| CONVERTING_TO_FILE char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='F';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->conv_type=$<ptr>4;
		$<convert>$->filter=$<ptr>6;

	}
	| CONVERTING_TO_PIPE char_or_var_vl KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='|';
		$<convert>$->s1=$<ptr>2;
		$<convert>$->filter=$<ptr>6;
		$<convert>$->conv_type=$<ptr>4;
	}
	| CONVERTING_TO_PRINTER KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='P';
		$<convert>$->s1=0;
		$<convert>$->filter=$<ptr>5;
		$<convert>$->conv_type=$<ptr>3;
	}
	| CONVERTING_TO_EMAIL KW_AS char_or_var_vl KW_USING char_or_var_vl {
		$<convert>$=malloc(sizeof(struct convert));
		$<convert>$->towhat='@';
		$<convert>$->s1=0;
		$<convert>$->filter=$<ptr>5;
		$<convert>$->conv_type=$<ptr>3;
	}
;


term_rep_cmd : TERMINATE_REPORT rep_name {
		add_feature("USE_REPORT");
		ADDMAP("Terminate Report",$<str>2);
		$<cmd>$=new_term_rep_cmd($<str>2);
}
;


format_section: FORMAT EVERY_ROW {
	        $<report_format_section>$=malloc(sizeof(report_format_section));
                $<report_format_section>$->entries.entries_len=1;
                $<report_format_section>$->entries.entries_val=malloc(sizeof($<report_format_section>$->entries.entries_val[0]) * $<report_format_section>$->entries.entries_len);
                $<report_format_section>$->entries.entries_val[$<report_format_section>$->entries.entries_len-1]=new_report_format_section_entry(RB_FORMAT_EVERY_ROW,0, NULL,0, yylineno);
			$<report_format_section>$->lines_in_header=rep_struct.lines_in_header;
			$<report_format_section>$->lines_in_first_header=rep_struct.lines_in_first_header;
			$<report_format_section>$->lines_in_trailer=rep_struct.lines_in_trailer;
}
| 
FORMAT format_actions {$<report_format_section>$=$<report_format_section>2;
			$<report_format_section>$->lines_in_header=rep_struct.lines_in_header;
			$<report_format_section>$->lines_in_first_header=rep_struct.lines_in_first_header;
			$<report_format_section>$->lines_in_trailer=rep_struct.lines_in_trailer;
}
;

format_actions : format_action  {
		$<report_format_section>$=malloc(sizeof(report_format_section));
		$<report_format_section>$->entries.entries_len=1;
		$<report_format_section>$->entries.entries_val=malloc(sizeof($<report_format_section>$->entries.entries_val[0]) * $<report_format_section>$->entries.entries_len);
		$<report_format_section>$->entries.entries_val[$<report_format_section>$->entries.entries_len-1]=$<report_format_section_entry>1;
		}

	| format_actions format_action {
		$<report_format_section>$=$<report_format_section>1;
		$<report_format_section>$->entries.entries_len=$<report_format_section>1->entries.entries_len+1;
		$<report_format_section>$->entries.entries_val=realloc($<report_format_section>1->entries.entries_val, sizeof($<report_format_section>$->entries.entries_val[0]) * $<report_format_section>$->entries.entries_len);
		$<report_format_section>$->entries.entries_val[$<report_format_section>$->entries.entries_len-1]=$<report_format_section_entry>2;
	}
;



format_action :
	 FIRST_PAGE_HEADER { push_report_block("FIRST",'P',""); } atline commands_as_list {
		int lineno; char errmsg[256];
	 	add_feature("REPORT_FIRST_PAGE_HEADER");
		set_cmdlineno($<integer_val>3);
		rep_struct.lines_in_first_header=A4GL_check_lines_for_prints($<commands>4,&lineno,errmsg);
		pdf_rep_struct.lines_in_first_header=rep_struct.lines_in_first_header;
		$<report_format_section_entry>$=new_report_format_section_entry(RB_FIRST_PAGE_HEADER,NULL, $<commands>4,0,$<integer_val>3);
		}
	| PAGE_TRAILER { add_feature("REPORT_PAGE_TRAILER"); push_report_block("TRAILER",'T',"");
 		} atline commands_as_list {
		int lineno; char errmsg[256];
		set_cmdlineno($<integer_val>3);
		rep_struct.lines_in_trailer=A4GL_check_lines_for_prints($<commands>4,&lineno,errmsg);
		pdf_rep_struct.lines_in_trailer=rep_struct.lines_in_trailer;
	
		if (rep_struct.lines_in_trailer==-1) {
				yylineno=lineno;
				posterror=1; /* Ensure the error file is reread - because the linenumber here will be after the PAGE TRAILER - not at the IF statement */
		                a4gl_yyerror(errmsg);
                                YYERROR;
		}


		$<report_format_section_entry>$=new_report_format_section_entry(RB_PAGE_TRAILER,NULL, $<commands>4,0,$<integer_val>3);
	}
	| PAGE_HEADER { push_report_block("HEADER",'p',""); } atline commands_as_list {
		int lineno; char errmsg[256];
	 	add_feature("REPORT_PAGE_HEADER");
		set_cmdlineno($<integer_val>3);
		rep_struct.lines_in_header=A4GL_check_lines_for_prints($<commands>4,&lineno,errmsg);
		pdf_rep_struct.lines_in_header=rep_struct.lines_in_header;
		$<report_format_section_entry>$=new_report_format_section_entry(RB_PAGE_HEADER,NULL, $<commands>4,0,$<integer_val>3);
	}
	| ON_EVERY_ROW { push_report_block("EVERY",'E',""); add_feature("ON_EVERY_ROW");  } atline commands_as_list {
		set_cmdlineno($<integer_val>3);
		$<report_format_section_entry>$=new_report_format_section_entry(RB_ON_EVERY_ROW,NULL, $<commands>4,0,$<integer_val>3);
		}
	| ON_LAST_ROW { push_report_block("LAST",'L',""); add_feature("ON_LAST_ROW"); } atline commands_as_list {
		set_cmdlineno($<integer_val>3);
		$<report_format_section_entry>$=new_report_format_section_entry(RB_ON_LAST_ROW,NULL, $<commands>4,0,$<integer_val>3);
	}
	| BEFGROUP variable_usage_expression  {
		int a;
		char buff[80];
		
		a=scan_orderby(current_orderby, $<ptr>2);
		if (a<0) {
   			SPRINTF1(buff,"%s is not in the order by list",get_variable_as_string_from_variable_usage_expression($<ptr>2)); //@FIXME
   			a4gl_yyerror(buff);
			YYERROR;
		}
		inc_var_usage($<ptr>2);
		add_feature("REPORT_BEFORE_GROUP");
		SPRINTF1(buff,"%d",a+1);
		push_report_block(buff,'B',$<str>2);
		set_curr_block(a+1);
		 } atline commands_as_list {
			int a;
			a=scan_orderby(current_orderby, $<ptr>2)+1;
		set_cmdlineno($<integer_val>4);

		$<report_format_section_entry>$=new_report_format_section_entry(RB_BEFORE_GROUP_OF,$<ptr>2, $<commands>5,a,$<integer_val>4);
	}
	| AFTGROUP variable_usage_expression { 
		int a;
		char buff[80];
		add_feature("REPORT_AFTER_GROUP");
		
		inc_var_usage($<ptr>2);
		
		a=scan_orderby(current_orderby, $<ptr>2);
		if (a<0) {
   			SPRINTF1(buff,"%s is not in the order by list",get_variable_as_string_from_variable_usage_expression($<ptr>2));
   			a4gl_yyerror(buff);
			YYERROR;
		}
		
		
		SPRINTF1(buff,"%d",a+1);
		push_report_block(buff,'A',$<str>2);
		set_curr_block(a+1);
		} atline  commands_as_list {
			int a;
			set_cmdlineno($<integer_val>4);
			a=scan_orderby(current_orderby, $<ptr>2)+1;

			$<report_format_section_entry>$=new_report_format_section_entry(RB_AFTER_GROUP_OF,$<ptr>2, $<commands>5, a,$<integer_val>4);
		}
;


need_cmd :
	 NEED fgl_expr_c  KWLINE {
		$<cmd>$=new_need_cmd(chk_expr($<ptr>2));
	}
;

op_lines : {strcpy($<str>$,"0");} | KWLINE {strcpy($<str>$,"1");}
;



skip_cmd : 
	SKIP atline fgl_expr_c op_lines {
			char buff[256];
			strcpy(buff,$<str>4);
			set_cmdlineno($<integer_val>2);
			if (buff[0]=='1') {
				$<cmd>$=new_skip_cmd($<ptr>3);
			} else {
				if (rep_type!=REP_TYPE_PDF) { 
					a4gl_yyerror("SKIP BY is only in PDF reports"); YYERROR; 
				} 
				$<cmd>$=new_skip_by_cmd($<ptr>3);
			}
	}
	;


skip_to_top_cmd : 
	SKIP_TO_TOP { $<cmd>$=new_command(E_CMD_SKIP_TO_TOP_CMD);}
;


skip_by_cmd :  SKIP_BY pdf_expr {
		//double n;
			//n=atof($<str>2);
			if (rep_type!=REP_TYPE_PDF) {
				a4gl_yyerror("SKIP BY is only in PDF reports");
				YYERROR;
			}
			$<cmd>$=new_skip_by_cmd($<ptr>2);
		}
;

skip_to_cmd : SKIP_TO pdf_expr {
			//double n;
			//n=atof($<str>2);
			if (rep_type!=REP_TYPE_PDF) {
				a4gl_yyerror("SKIP TO is only in PDF reports");
				YYERROR;
			}
			$<cmd>$=new_skip_to_cmd($<ptr>2);
		}


;


opt_rep_expr_list : {$<ptr_list>$=0;}
	| xrep_expr_list {$<ptr_list>$=$<ptr_list>1;}
;

xrep_expr_list: rep_expr_list opt_print_at  {
		$<ptr_list>$=$<ptr_list>1;
	}
;

opt_print_at : | KW_AT nval {
	print_niy("PRINT AT...");
}
;

print_cmd : PRINT atline opt_rep_expr_list opt_semi_b {
	char wt;
	doing_a_print=0;

	set_cmdlineno($<integer_val>2);


	$<cmd>$=new_print_cmd(	make_fgl_expr_list($<ptr_list>3), $<e_boolean>4);

	if (!isin_command("REPORT")) {
                        a4gl_yyerror("PRINT can only be used in a report. Did you mean DISPLAY ?");
                        YYERROR;
	}
	wt=get_curr_report_stack_whytype_1();
	if ($<e_boolean>4==0) {
		if (wt=='P'||wt=='p'||wt=='T') { /* Page header or trailer */
			if (isin_command("WHILE")||isin_command("FOR")) {
				a4gl_yyerror("You can't print within a loop in a PAGE HEADER or PAGE TRAILER");
				YYERROR;
			}
		}
	}
} 

;


pf_char_or_var:
	char_or_var_vl {$<ptr>$=$<ptr>1;}
	| OPEN_BRACKET char_or_var_vl CLOSE_BRACKET {
		$<ptr>$=$<ptr>2;
	}
;


print_file_cmd : 
	PRINT_FILE pf_char_or_var opt_semi_b { 
	add_feature("PRINT_FILE");
	if (!isin_command("REPORT")) {
                        a4gl_yyerror("PRINT can only be used in a report. Did you mean DISPLAY ?");
                        YYERROR;
	}
	$<cmd>$=new_print_file_cmd($<ptr>2, $<e_boolean>3);
} ;


print_img_cmd : 
	PRINT_IMAGE blob_var_or_char_var_or_char_literal  img_types opt_scaling opt_semi_b { 
		if (!isin_command("REPORT")) {
                        a4gl_yyerror("PRINT can only be used in a report. Did you mean DISPLAY ?");
                        YYERROR;
		}

		$<cmd>$=new_print_img_cmd($<ptr>2,
				chk_expr($<pair_expr>4.s2),
				chk_expr($<pair_expr>4.s1),$<str>3,$<e_boolean>5);
		
	} 
;

opt_scaling :
	{ 
		$<pair_expr>$.s1=A4GL_new_literal_double_str("1.0");
		$<pair_expr>$.s2=A4GL_new_literal_double_str("1.0");
	}
	| SCALED_BY fgl_expr_c { 
		$<pair_expr>$.s1=$<ptr>2;
		$<pair_expr>$.s2=$<ptr>2;
	}
	| SCALED_BY fgl_expr_c KW_COMMA fgl_expr_c {
		$<pair_expr>$.s1=$<ptr>2;
		$<pair_expr>$.s2=$<ptr>4;
	}
;

img_types : 	
	AS_TIFF {strcpy($<str>$,"tiff");}
	| AS_GIF {strcpy($<str>$,"gif");}
	| AS_PNG {strcpy($<str>$,"png");}
	| AS_JPEG {strcpy($<str>$,"jpeg");}
;


blob_var_or_char_var_or_char_literal :  variable_usage_expression {
						int vtype;
						char errbuff[256];
						vtype=get_variable_dtype_from_variable_usage_expression(errbuff,$<ptr>1) ;
						if (vtype==-1) {
							a4gl_yyerror(errbuff);
							YYERROR;
						} else {
							vtype=vtype&DTYPE_MASK;
							if (vtype!=DTYPE_BYTE&&vtype!=DTYPE_TEXT && vtype!=DTYPE_CHAR && vtype!=DTYPE_VCHAR) {
								a4gl_yyerror("Only Blobs and character strings (containing a path) may be printed...");
								YYERROR;
							}
						}
						$<ptr>$=$<ptr>1;
						inc_var_usage($<ptr>$);
				} 
		|  CHAR_VALUE  {
                		if (strcmp($<str>1,"\"\"")==0) {
					a4gl_yyerror("You can't use an empty character string here.");
					YYERROR;
                		} else {
                        		$<ptr>$=A4GL_new_literal_string(A4GL_strip_quotes($<str>1));
                		}
        	}
;

opt_semi_b : { $<e_boolean>$=EB_FALSE; } | SEMICOLON { $<e_boolean>$=EB_TRUE; };

rep_expr_list : rep_expr_p {
		$<ptr_list>$=A4GL_new_ptr_list($<ptr>1);
} 
| rep_expr_list KW_COMMA rep_expr_p {
	$<ptr_list>$=A4GL_new_append_ptr_list($<ptr_list>1,$<ptr>3);
}
;

rep_expr_p : fgl_expr_c op_wordwrap {
	if ($<ptr>2==0) {
		$<ptr>$=$<ptr>1;
	} else {
		$<ptr>$=A4GL_new_expr_wordwrap($<ptr>1,$<ptr>2);
	}
}
;

rep_agg : 
	KW_SUM atline OPEN_BRACKET fgl_expr_c CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('S',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| COUNT_MULTIPLY atline rep_where
		{
		long a;
		$<ptr>$=add_report_agg('C',0,$<ptr>3,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| COUNT atline OPEN_BRACKET KW_MULTIPLY CLOSE_BRACKET rep_where
		{
		long a;
		$<ptr>$=add_report_agg('C',0,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| PERCENT   atline OPEN_BRACKET KW_MULTIPLY CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('P',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
	}
	| AVERAGE  atline  OPEN_BRACKET fgl_expr_c CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('A',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| AVG  atline  OPEN_BRACKET fgl_expr_c CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('A',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| XMIN    atline    OPEN_BRACKET fgl_expr_c CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('N',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
	| XMAX    atline    OPEN_BRACKET fgl_expr_c CLOSE_BRACKET  rep_where
		{
		long a;
		$<ptr>$=add_report_agg('X',$<ptr>4,$<ptr>6,racnt,&a,$<integer_val>2);
		racnt+=a;
		}
;

op_output_section : {$<startrep>$=0;} | OUTPUT output_commands  {
	                $<startrep>$=malloc(sizeof(startrep));
                        $<startrep>$->with_page_length=rep_struct.page_length;
                        $<startrep>$->with_left_margin=rep_struct.left_margin;
                        $<startrep>$->with_right_margin= rep_struct.right_margin;
                        $<startrep>$->with_top_margin= rep_struct.top_margin;
                        $<startrep>$->with_bottom_margin= rep_struct.bottom_margin;
                        $<startrep>$->with_top_of_page= strdup(rep_struct.top_of_page);
                        $<startrep>$->towhat=rep_struct.output_mode;
			$<startrep>$->s1=rep_struct.output_loc;
}
;

output_commands : output_command | output_commands output_command;

output_command : 
  LEFT_MARGIN INT_VALUE 		{rep_struct.left_margin=atoi($<str>2);}
| RIGHT_MARGIN INT_VALUE 		{rep_struct.right_margin=atoi($<str>2);}
| TOP_MARGIN INT_VALUE 			{rep_struct.top_margin=atoi($<str>2);}
| BOTTOM_MARGIN INT_VALUE 		{rep_struct.bottom_margin=atoi($<str>2);}
| PAGE_LENGTH INT_VALUE 		{rep_struct.page_length=atoi($<str>2);}
| REPORT_TO_PRINTER  			{rep_struct.output_mode='R';rep_struct.output_loc=A4GL_new_expr_simple(ET_EXPR_REPORT_PRINTER);}
| REPORT_TO_FILE CHAR_VALUE 			{rep_struct.output_mode='F';rep_struct.output_loc=A4GL_new_literal_string(A4GL_strip_quotes($<str>2)); }
| REPORT_TO CHAR_VALUE 			{rep_struct.output_mode='F';rep_struct.output_loc=A4GL_new_literal_string(A4GL_strip_quotes($<str>2)); }
| REPORT_TO ensured_variable_usage_expression 	{rep_struct.output_mode='F';rep_struct.output_loc=$<ptr>2;  }
| REPORT_TO_PIPE CHAR_VALUE 		{rep_struct.output_mode='P';rep_struct.output_loc=A4GL_new_literal_string(A4GL_strip_quotes($<str>2));} 
| REPORT_TO_UI  		{rep_struct.output_mode='U';rep_struct.output_loc=A4GL_new_expr_simple(ET_EXPR_REPORT_UI);} 
| REPORT_TO_PIPE ensured_variable_usage_expression 	{rep_struct.output_mode='P';rep_struct.output_loc=$<ptr>2;}
| TOP_OF_PAGE CHAR_VALUE 		{strcpy(rep_struct.top_of_page,$<str>2);}
;

pdf_output_commands : pdf_output_command | pdf_output_commands pdf_output_command;


nval: nval_number KW_POINTS {SPRINTF1($<str>$,"-%f",atof($<str>1));}
	| nval_number INCHES {SPRINTF1($<str>$,"-%f",atof($<str>1)*72.0); }
	| nval_number CM {SPRINTF1($<str>$,"-%f",atof($<str>1)*28.3465); }
	| nval_number MM     {SPRINTF1($<str>$,"-%f",atof($<str>1)*2.83465);}
	| nval_number        {SPRINTF1($<str>$,"%f",atof($<str>1));} 
;

nval_number: real_number | INT_VALUE
;

pdf_op_output_section : {$<pdf_startrep>$=0;} | OUTPUT pdf_output_commands 
	{
		resize_paper(&pdf_rep_struct);
		$<pdf_startrep>$=malloc(sizeof(pdf_startrep));
	        $<pdf_startrep>$->towhat=pdf_rep_struct.output_mode;
         	$<pdf_startrep>$->s1=pdf_rep_struct.output_loc;
         	$<pdf_startrep>$->with_page_length=pdf_rep_struct.page_length;
         	$<pdf_startrep>$->with_page_width=pdf_rep_struct.page_width;
        	$<pdf_startrep>$->with_left_margin=pdf_rep_struct.left_margin;
        	$<pdf_startrep>$->with_right_margin=pdf_rep_struct.right_margin;
         	$<pdf_startrep>$->with_top_margin=pdf_rep_struct.top_margin;
         	$<pdf_startrep>$->with_bottom_margin=pdf_rep_struct.bottom_margin;
         	$<pdf_startrep>$->fontname=strdup(pdf_rep_struct.font_name);
        	$<pdf_startrep>$->fontsize=pdf_rep_struct.font_size;
        	$<pdf_startrep>$->papersize=pdf_rep_struct.paper_size;
		$<pdf_startrep>$->bluebar.style=pdf_rep_struct.bluebar_style;
		$<pdf_startrep>$->bluebar.r=pdf_rep_struct.bluebar_r;
		$<pdf_startrep>$->bluebar.g=pdf_rep_struct.bluebar_g;
		$<pdf_startrep>$->bluebar.b=pdf_rep_struct.bluebar_b;
        	$<pdf_startrep>$->pageheadersize=0.0;
        	$<pdf_startrep>$->firstpageheadersize=0.0;
         	$<pdf_startrep>$->pagetrailersize=0.0;
        	$<pdf_startrep>$->isdefault=EB_NOTSET;
        	$<pdf_startrep>$->ascii_height=EB_NOTSET;
        	$<pdf_startrep>$->ascii_width=EB_NOTSET;

}
;

pdf_output_command : 
  LEFT_MARGIN nval {pdf_rep_struct.left_margin=atof($<str>2);
#ifdef DEBUG
A4GL_debug("Left margin=%s\n",$<str>2);
#endif
}
| RIGHT_MARGIN nval {pdf_rep_struct.right_margin=atof($<str>2);}
| TOP_MARGIN nval {pdf_rep_struct.top_margin=atof($<str>2);}
| BOTTOM_MARGIN nval {pdf_rep_struct.bottom_margin=atof($<str>2);}
| PAGE_LENGTH nval {pdf_rep_struct.page_length=atof($<str>2);}
| PAGE_WIDTH nval {pdf_rep_struct.page_width=atof($<str>2);}
| FONT_NAME CHAR_VALUE {strcpy(pdf_rep_struct.font_name,$<str>2);}
| FONT_SIZE nval {pdf_rep_struct.font_size=atof($<str>2);}

| PAPER_SIZE_IS_A4  {pdf_rep_struct.paper_size=1;}
| PAPER_SIZE_IS_LETTER  {pdf_rep_struct.paper_size=2;}
| PAPER_SIZE_IS_LEGAL  {pdf_rep_struct.paper_size=3;}
| PAPER_SIZE_IS_A5  {pdf_rep_struct.paper_size=5;}

| PAPER_SIZE_IS_A4_L  {pdf_rep_struct.paper_size=-1;}
| PAPER_SIZE_IS_LETTER_L  {pdf_rep_struct.paper_size=-2;}
| PAPER_SIZE_IS_LEGAL_L  {pdf_rep_struct.paper_size=-3;}
| PAPER_SIZE_IS_A5_L  {pdf_rep_struct.paper_size=-5;}

| PAGE_TRAILER_SIZE nval 
| PAGE_HEADER_SIZE nval 
| FIRST_PAGE_HEADER_SIZE nval 
| REPORT_TO CHAR_VALUE {pdf_rep_struct.output_mode='F';pdf_rep_struct.output_loc=A4GL_new_literal_string(A4GL_strip_quotes($<str>2));}
| REPORT_TO_PIPE CHAR_VALUE {pdf_rep_struct.output_mode='P';pdf_rep_struct.output_loc=A4GL_new_literal_string(A4GL_strip_quotes($<str>2));}
| KW_DEFAULT
| ASCII_HEIGHT_ALL
| ASCII_WIDTH_ALL
| BLUEBAR  {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_RECTANGLE;
}
| BLUEBAR_STYLE_EQUAL_RECTANGLE {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_RECTANGLE;
	}
| BLUEBAR_STYLE_EQUAL_LINE {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_5LINE;
	}
| BLUEBAR_COLOR_EQUAL NUMBER_VALUE KW_COMMA NUMBER_VALUE KW_COMMA NUMBER_VALUE {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_RECTANGLE;
		pdf_rep_struct.bluebar_r=atof($<str>2);
		pdf_rep_struct.bluebar_g=atof($<str>4);
		pdf_rep_struct.bluebar_b=atof($<str>6);
	
	}
| BLUEBAR_STYLE_EQUAL_RECTANGLE_COLOR_EQUAL NUMBER_VALUE KW_COMMA NUMBER_VALUE KW_COMMA NUMBER_VALUE {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_RECTANGLE;
		pdf_rep_struct.bluebar_r=atof($<str>2);
		pdf_rep_struct.bluebar_g=atof($<str>4);
		pdf_rep_struct.bluebar_b=atof($<str>6);
	}
| BLUEBAR_STYLE_EQUAL_LINE_COLOR_EQUAL NUMBER_VALUE KW_COMMA NUMBER_VALUE KW_COMMA NUMBER_VALUE {
		pdf_rep_struct.bluebar_style=E_BLUEBAR_5LINE;
		pdf_rep_struct.bluebar_r=atof($<str>2);
		pdf_rep_struct.bluebar_g=atof($<str>4);
		pdf_rep_struct.bluebar_b=atof($<str>6);
	}
;


op_rep_order_by : {
	$<report_orderby_section>$=new_report_orderby_section(REPORT_ORDERBY_IMPLICIT, NULL);
} 
	| rep_order_by
;

rep_order_by : 
ORDER KW_BY obind_var_list_ord
{
	add_feature("REPORT_ORDER_BY");
	$<report_orderby_section>$=new_report_orderby_section(REPORT_ORDERBY, $<ptr_list>3);
	/* We are marking the variables as being used *just* for ORDER BY, not ORDER EXTERNAL BY
		as the variables are not *really* used for the ORDER EXTERNAL - its just indicative of
		the order
	*/
	inc_var_assigned_from_binding_list($<ptr_list>3);
	inc_var_usage_from_binding_list($<ptr_list>3);
}
| ORDER_EXTERNAL_BY obind_var_list_ord {
	$<report_orderby_section>$=new_report_orderby_section(REPORT_ORDERBY_EXTERNAL, $<ptr_list>2);
}
;


rep_or_localrep:  REPORT {$<e_boolean>$=EB_FALSE;} | LOCAL_REPORT {$<e_boolean>$=EB_TRUE;}
;

report_def : op_doc4gl_comment   rep_or_localrep
	{ 
		add_feature("USE_REPORT");
		A4GL_clr_extra_warnings();
    		//if (class_cnt>1) { a4gl_yyerror("You've already defined a class - you can't do any more now"); }
		rep_type=REP_TYPE_NORMAL; 
		clr_function_constants (); 
		clr_variable(); 
				clr_call_list();
		lastlineno=yylineno; 
		init_report_structure(&rep_struct); 
		}
	identifier  atline
	OPEN_BRACKET
	{
		inc_report_cnt();
		SPRINTF1(curr_func,"%s",$<str>4);
		ADDMAP_MODULE("Define Report",curr_func);
		map_report_start(curr_func);
		//variable_action(-1,$<str>4,"","","add_function");
		set_curr_rep_name($<str>4);
		push_blockcommand("REPORT");
		}
	op_param_var_list CLOSE_BRACKET define_section  {
			if (check_for_bad_report_variables($10)) {
				a4gl_yyerror("Invalid variable name - you can't use PAGENO or LINENO for your own variables in a repor");
				YYERROR;
			}
	} op_output_section op_rep_order_by  {
			char errbuff[256];
			expr_str_list *expanded_parameters;
			add_report_definition($<str>4,$<ptr_list>8);
			if (!check_parameters(errbuff,$10, $<ptr_list>8)) {
				a4gl_yyerror(errbuff);
				YYERROR;
			}
			expanded_parameters=expand_parameters($10,$<ptr_list>8);
			inc_var_assigned_from_binding_list(expanded_parameters);
			set_report_orderby($10, $<ptr_list>8, $<report_orderby_section>13);
		}
	format_section END_REPORT 
		{
		pop_blockcommand("REPORT");
 			A4GL_chk_and_clr_labels();
			map_report_end();
                	$<module_entry>$=new_report_definition($<str>4, $<e_boolean>2,$<ptr_list>8, $<startrep>12, $<report_orderby_section>13, $<report_format_section>15 ,$<integer_val>5,$<sql_string>1) ;
			//set_variables(&$<module_entry>$->module_entry_u.report_definition.variables,'L');

                        merge_variable_list(&$<module_entry>$->module_entry_u.report_definition.variables, $10);
                        sort_variables_v(&$<module_entry>$->module_entry_u.report_definition.variables);

			clr_function_constants();
			 A4GL_chk_and_clr_labels();
			rep_type=REP_TYPE_NOTSET; 
			//variable_add_function($<module_entry>$);
			$<module_entry>$->module_entry_u.report_definition.expanded_parameters=expand_parameters( &$<module_entry>$->module_entry_u.report_definition.variables, $<module_entry>$->module_entry_u.report_definition.parameters);
		}
;



rep_where :  { strcpy($<str>$,"");
	$<ptr>$=0;
}
| WHERE fgl_expr_c {
	$<ptr>$=$<ptr>2;
}
;



pdf_specific_cmd : 
	SET_COLOR fgl_expr_c KW_COMMA fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("setcolor",NULL, $<ptr>2,$<ptr>4,$<ptr>6,NULL);
	}
	| SET_STROKE_COLOR fgl_expr_c KW_COMMA fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("setstrokecolor",NULL, $<ptr>2,$<ptr>4,$<ptr>6,NULL);
	}
	| SET_FILL_COLOR fgl_expr_c KW_COMMA fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("setfillcolor",NULL, $<ptr>2,$<ptr>4,$<ptr>6,NULL);
	}
	| STROKE {
			$<cmd>$=new_pdf_specific_cmd("stroke",NULL, NULL);
	}
	| SET_PARAMETER fgl_expr_c KW_COMMA fgl_expr_c  {
			$<cmd>$=new_pdf_specific_cmd("set_parameter",NULL, $<ptr>2,$<ptr>4,NULL);
	}
	| MOVE_TO  fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("moveto",NULL, report_position_expr_x($<ptr>4) , report_position_expr_y($<ptr>2),NULL);
	}
	| MOVE_TO_TOP  fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("moveto_top",NULL, report_position_expr_x($<ptr>4), report_position_expr_y($<ptr>2),NULL);
	}
	| LINE_TO  fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("lineto",NULL, report_position_expr_x($<ptr>4), report_position_expr_y($<ptr>2),NULL);
	}
	| LINETO_TOP  fgl_expr_c KW_COMMA fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("lineto_top",NULL, report_position_expr_x($<ptr>4), report_position_expr_y($<ptr>2),NULL);
	}

	| BOOKMARK fgl_expr_c KW_COMMA fgl_expr_c opt_return {
			if ($<ptr_list>5==NULL) {
			$<cmd>$=new_pdf_specific_cmd("add_bookmark_no_ret",$<ptr_list>5, $<ptr>4,$<ptr>2,NULL);
			} else {
			$<cmd>$=new_pdf_specific_cmd("add_bookmark",$<ptr_list>5, $<ptr>4,$<ptr>2,NULL);
			}
	}
	| BOOKMARK fgl_expr_c opt_return {
			struct expr_str *p;
			p=A4GL_new_literal_long_long(0);
			if ($<ptr_list>3==NULL) {
				$<cmd>$=new_pdf_specific_cmd("add_bookmark_no_ret",$<ptr_list>3, $<ptr>2,p,NULL);
			} else {
				$<cmd>$=new_pdf_specific_cmd("add_bookmark",$<ptr_list>3, $<ptr>2,p,NULL);
			}
	}
	| BARCODETYPE fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("barcode_type",NULL, $<ptr>2,NULL);
	}
	| BARCODE fgl_expr_c KW_WIDTH fgl_expr_c KW_HEIGHT fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("barcode",NULL, 
				report_position_current_x(),
				report_position_current_y(),
				$<ptr>4,
				$<ptr>6,
				$<ptr>2,
				 NULL);
	}
	| BARCODE_NO_TEXT fgl_expr_c KW_WIDTH fgl_expr_c KW_HEIGHT fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("barcode_no_text",NULL, 
				report_position_current_x(),
				report_position_current_y(),
				$<ptr>4,
				$<ptr>6,
				$<ptr>2,
				 NULL);
	}
	| BARCODE fgl_expr_c KW_AT fgl_expr_c KW_COMMA fgl_expr_c KW_WIDTH fgl_expr_c KW_HEIGHT fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("barcode",NULL, 
				report_position_expr_x($<ptr>6),
				report_position_expr_y($<ptr>4),
				$<ptr>8,
				$<ptr>10,
				$<ptr>2,
				 NULL);
	}
	| BARCODE_NO_TEXT fgl_expr_c KW_AT fgl_expr_c KW_COMMA fgl_expr_c KW_WIDTH fgl_expr_c KW_HEIGHT fgl_expr_c {
			$<cmd>$=new_pdf_specific_cmd("barcode_no_text",NULL,
				report_position_expr_x($<ptr>6),
				report_position_expr_y($<ptr>4),
				$<ptr>8,
				$<ptr>10,
 				$<ptr>2,
				 NULL);
	}

	| FILL_STROKE {
			$<cmd>$=new_pdf_specific_cmd("fill_stroke",NULL, NULL);
	}
	| KW_FILL {
			$<cmd>$=new_pdf_specific_cmd("fill",NULL, NULL);
	}
	| SET_TEXT_FORMAT  fgl_expr_c  {
			$<cmd>$=new_pdf_specific_cmd("set_text_format",NULL, $<ptr>2,NULL);
	}
	| SET_FONT_SIZE  fgl_expr_c  {
			$<cmd>$=new_pdf_specific_cmd("set_font_size",NULL, $<ptr>2,NULL);
	}
	| SET_FONT_NAME  fgl_expr_c  {
			$<cmd>$=new_pdf_specific_cmd("set_font_name",NULL, $<ptr>2,NULL);
	}
;

pause_cmd : 
	PAUSE pause_msg {
		if (!in_command("REPORT")) {
			a4gl_yyerror("PAUSE can only be used in reportes");
			YYERROR;
        		}
		$<cmd>$=new_pause_cmd($<ptr>2);
	}

;

pause_msg : {$<ptr>$=0;}
	| char_or_var_vl {$<ptr>$=$<ptr>1;}
;



pdf_rep_or_localrep:  PDF_REPORT {$<e_boolean>$=EB_FALSE;} | LOCAL_PDF_REPORT {$<e_boolean>$=EB_TRUE;}
;

pdf_report_def : op_doc4gl_comment  pdf_rep_or_localrep {
				A4GL_clr_extra_warnings();
    	//if (class_cnt>1) { a4gl_yyerror("You've already defined a class - you can't do any more now"); }
		rep_type=REP_TYPE_PDF;
		clr_function_constants();
		clr_variable(); 
				clr_call_list();
		lastlineno=yylineno; 
		pdf_init_report_structure(&pdf_rep_struct);
		}
	identifier atline OPEN_BRACKET
		{
		inc_report_cnt();
		SPRINTF1(curr_func,"%s",$<str>4);
		ADDMAP_MODULE("Define PDF Report",curr_func);
		set_curr_rep_name($<str>4);
		push_blockcommand("REPORT");
		}
	op_param_var_list CLOSE_BRACKET define_section  {
			//set_local_variables($10);
                        if (check_for_bad_report_variables($10)) {
                                a4gl_yyerror("Invalid variable name - you can't use PAGENO or LINENO for your own variables in a report");
                                YYERROR;
                        }

		} pdf_op_output_section op_rep_order_by  
		{
			char errbuff[256];
			if (!check_parameters(errbuff,$10, $<ptr_list>8)) {
				a4gl_yyerror(errbuff);
				YYERROR;
			}
			set_report_orderby($10, $<ptr_list>8, $<report_orderby_section>13);
		}
	format_section END_REPORT { 
		pop_blockcommand("REPORT"); 
                	$<module_entry>$=new_pdf_report_definition($<str>4, $<e_boolean>2,$<ptr_list>8, $<pdf_startrep>12, $<report_orderby_section>13, $<report_format_section>15,$<integer_val>5 ,$<sql_string>1) ;
			//set_variables(&$<module_entry>$->module_entry_u.pdf_report_definition.variables,'L');

                         merge_variable_list(&$<module_entry>$->module_entry_u.pdf_report_definition.variables, $10);
                         sort_variables_v(&$<module_entry>$->module_entry_u.pdf_report_definition.variables);
		$<module_entry>$->module_entry_u.pdf_report_definition.expanded_parameters=expand_parameters( &$<module_entry>$->module_entry_u.pdf_report_definition.variables, $<module_entry>$->module_entry_u.pdf_report_definition.parameters);
			clr_function_constants();
			 A4GL_chk_and_clr_labels();
			rep_type=REP_TYPE_NOTSET; 
			//variable_add_function($<module_entry>$);
		
	}
;


pdf_functions_expr :
	PDF_FUNCTION OPEN_BRACKET CHAR_VALUE KW_COMMA opt_func_call_args CLOSE_BRACKET {
			if (rep_type==REP_TYPE_NORMAL) {
				a4gl_yyerror("You can't use a pdf function in a non-pdf report");
				$<ptr>$=0;
			} else {
				// REP_TYPE_PDF or REP_TYPE_NOTSET(a function)
   				ADDMAP("CALL",$<str>3);
		                $<ptr>$=A4GL_new_expr_pdf_fcall($<str>3,$<ptr_list>5,A4GL_compiling_module_basename(),lastlineno,get_namespace($<str>3));
			}
   		}
;


op_wordwrap:
	{$<ptr>$=0;} 
 	| KW_WORDWRAP { $<ptr>$=A4GL_new_literal_long_long(0);} /* @ FIXME - use default right margin */
	| KW_WORDWRAP RIGHT_MARGIN fgl_expr_c { $<ptr>$=$<ptr>3; }
;

/* ============================ report.rule ========================== */