/*********************************
		 *                               *
		 *   Visual Shell v1.17  10/92   *
		 *                               *
		 *     by Torsten Jürgeleit      *
		 *                               *
		 *     prototypes & pragmas      *
		 *                               *
		 *********************************/

	/* action1.c */

VOID perform_action(VOID);
BOOL perform_intuitick_action(VOID);
VOID action_switch(VOID);
VOID action_display_mode(VOID);
VOID action_duplicate(VOID);
VOID action_freq_mode(USHORT mode);
#pragma	regcall(action_freq_mode(d0))
VOID action_edit(VOID);
VOID action_help(VOID);
VOID action_about(VOID);
VOID action_jump_to_freq_entry(VOID);

	/* action2.c */

VOID action_parent_dir(VOID);
VOID action_read_again(VOID);
VOID action_root_dir(VOID);
VOID action_new_dir(USHORT mode);
#pragma	regcall(action_new_dir(d0))
VOID action_read_again(VOID);
VOID action_enter(VOID);
VOID action_force_base(VOID);
VOID action_force_full(VOID);
VOID action_num_lock(VOID);
VOID action_search_pattern(VOID);
VOID action_mark_file(VOID);
VOID action_unmark_all_files(VOID);
VOID action_user_function(USHORT num);
#pragma	regcall(action_user_function(d0))
VOID action_change_user_function(USHORT num);
#pragma	regcall(action_change_user_function(d0))
VOID action_pattern_select(USHORT mode);
#pragma	regcall(action_pattern_select(d0))
VOID action_compare_directories(VOID);

	/* asmsupp1.asm */

struct InputEvent  *input_event_handler(struct InputEvent  *ievent,
								 APTR data);
#pragma	regcall(input_event_handler(a0,a1))
struct MinNode     *get_list_node(struct MinList  *list, ULONG num_entries,
								 ULONG pos);
#pragma	regcall(get_list_node(a0,d0,d1))
struct FileNode    *build_file_node(struct FileInfoBlock  *fib);
#pragma	regcall(build_file_node(a0))
struct FileNode    *build_dev_node(struct DevInfo  *dvi);
#pragma	regcall(build_dev_node(a0))
VOID   insert_file_node(struct FileNode  *fnode, struct MinList  *list);
#pragma	regcall(insert_file_node(a0,a1))
struct FileNode    *search_file_node(struct FileNode  *node, BYTE *name,
							   USHORT name_len);
#pragma	regcall(search_file_node(a0,a1,d0))
ULONG  count_file_nodes(struct MinList  *list);
#pragma	regcall(count_file_nodes(a0))
ULONG  recount_file_nodes(struct FileNode  *fnode);
#pragma	regcall(recount_file_nodes(a0))
VOID   sum_file_sizes(struct FileRequest  *freq);
#pragma	regcall(sum_file_sizes(a0))
USHORT get_view_mode(struct ViewRequest  *vreq);
#pragma	regcall(get_view_mode(a0))
BOOL   build_view_line_list(struct ViewRequest  *vreq, USHORT mode);
#pragma	regcall(build_view_line_list(a0,d0))
struct LineNode    *get_first_visible_line(struct ViewRequest  *vreq,
								 ULONG pos);
#pragma	regcall(get_first_visible_line(a0,d0))
struct LineNode    *search_line_node(struct LineNode  *node, BYTE *name,
							   USHORT name_len);
#pragma	regcall(search_line_node(a0,a1,d0))
BYTE   *protection(struct FileNode  *fnode);
#pragma	regcall(protection(a0))
VOID   build_limited_path_name(BYTE *buffer, BYTE *device_name,
			      BYTE *path_name, USHORT max_len, USHORT mode);
#pragma regcall(build_limited_path_name(a0,a1,a2,d0,d1))

	/* asmsupp2.asm */

VOID unpack_font(struct TextFont  *font, UBYTE *font_data);
#pragma	regcall(unpack_font(a0,a1))
VOID display_text(USHORT apen, USHORT bpen, USHORT xpos, USHORT ypos,
								BYTE *text);
VOID print_freq_lines(struct FileRequest  *freq, struct MinNode  *fnode,
						  USHORT start, USHORT num);
#pragma	regcall(print_freq_lines(a0,a1,d0,d1))
VOID hcomp_freq_cursor(struct FileRequest  *freq);
#pragma	regcall(hcomp_freq_cursor(a0))
VOID move_freq_cursor_down(struct FileRequest  *freq);
#pragma	regcall(move_freq_cursor_down(a0))
VOID scroll_file_req(VOID);
VOID print_vreq_lines(struct ViewRequest  *vreq, struct MinNode  *fnode,
						  USHORT start, USHORT num);
#pragma	regcall(print_vreq_lines(a0,a1,d0,d1))
BYTE *build_vreq_line(struct ViewRequest  *vreq, struct LineNode  *lnode,
								USHORT len);
#pragma	regcall(build_vreq_line(a0,a1,d0))
VOID hcomp_vreq_line(struct ViewRequest  *vreq, USHORT line);
#pragma	regcall(hcomp_vreq_line(a0,d0))
VOID scroll_view_req(VOID);
VOID print_quick_view_lines(struct FileRequest  *freq, BYTE *buffer,
								USHORT len);
#pragma	regcall(print_quick_view_lines(a0,a1,d0))

	/* asmsupp3.asm */

VOID hcomp_treq_cursor(struct TreeRequest  *treq);
#pragma regcall(hcomp_treq_cursor(a0))
VOID print_dir_tree(struct TreeRequest  *treq);
#pragma regcall(print_dir_tree(a0))
struct TreeNode  *get_tree_node_by_pos(struct TreeRequest  *treq,
						    ULONG xpos, ULONG ypos);
#pragma regcall(get_tree_node_by_pos(a0,d0,d1))
struct TreeNode  *get_next_column_tree_node(struct TreeNode  *tnode);
#pragma regcall(get_next_column_tree_node(a0))
struct TreeNode  *get_prev_column_tree_node(struct TreeNode  *tnode);
#pragma regcall(get_prev_column_tree_node(a0))
BOOL build_history_line_list(struct HistoryRequest  *hreq);
#pragma regcall(build_history_line_list(a0))
VOID print_hreq_lines(struct HistoryRequest  *hreq, struct LineNode  *lnode,
						 USHORT line, USHORT count);
#pragma regcall(print_hreq_lines(a0,a1,d0,d1))
BYTE *build_hreq_line(struct HistoryRequest  *vreq, struct LineNode  *lnode,
								USHORT len);
#pragma regcall(build_hreq_line(a0,a1,d0))
VOID hcomp_hreq_cursor(struct HistoryRequest  *hreq);
#pragma regcall(hcomp_hreq_cursor(a0))
VOID scroll_history_req(VOID);

	/* config.c */

VOID action_config(VOID);
VOID perform_config_action(struct Gadget  *gadget_list);
#pragma regcall(perform_config_action(a0))
VOID fill_config_gadget_buffers(struct Gadget  *gad);
#pragma regcall(fill_config_gadget_buffers(a0))
struct Gadget  *check_config(struct Gadget  *gadget_list);
#pragma regcall(check_config(a0))
VOID set_default_config(VOID);
VOID set_new_config(struct Gadget  *gad);
#pragma regcall(set_new_config(a0))
BOOL read_config_file(VOID);
BOOL read_config_data(BPTR fh, BYTE *buffer, ULONG size);
#pragma regcall(read_config_data(a0,a1,d0))
BOOL write_config_file(VOID);
BOOL write_config_data(BPTR fh, BYTE *buffer, ULONG size);
#pragma regcall(write_config_data(a0,a1,d0))

	/* display1.c */

VOID prepare_con_window(VOID);
VOID restore_con_window(VOID);
VOID move_and_resize_window(struct Window  *win, USHORT new_left,
		       USHORT new_top, USHORT new_width, USHORT new_height);
#pragma regcall(move_and_resize_window(a0,d0,d1,d2,d3))
VOID start_vsh(VOID);
VOID draw_display(USHORT mode);
#pragma regcall(draw_display(d0))
VOID refresh_display(VOID);
VOID clear_display(USHORT mode);
#pragma regcall(clear_display(d0))
VOID draw_requesters(USHORT mode);
#pragma regcall(draw_requesters(d0))
VOID draw_line(USHORT color, USHORT x1, USHORT y1, USHORT x2, USHORT y2);
#pragma regcall(draw_line(d0,d1,d2,d3,d4))
VOID mark_active_freq(VOID);
VOID print_status(SHORT status);
#pragma regcall(print_status(d0))
VOID print_dos_status(USHORT mode, BYTE *source, BYTE *dest);
#pragma regcall(print_dos_status(d0,a0,a1))
VOID print_vreq_status(struct ViewRequest  *vreq);
#pragma regcall(print_vreq_status(a0))
VOID print_treq_status(struct TreeRequest  *treq);
#pragma regcall(print_treq_status(a0))
VOID print_dir_name(struct FileRequest  *freq, BYTE *dir);
#pragma regcall(print_dir_name(a0,a1))
VOID print_info_line(USHORT mode);
#pragma regcall(print_info_line(d0))
VOID print_fkey_text(USHORT mode);
#pragma regcall(print_fkey_text(d0))
VOID display_text_left(USHORT front_color, USHORT back_color, USHORT x,
				      USHORT y, BYTE *text, USHORT max_len);
#pragma regcall(display_text_left(d0,d1,d2,d3,a0,d4))
VOID display_text_centered(USHORT front_color, USHORT back_color, USHORT x,
				      USHORT y, BYTE *text, USHORT max_len);
#pragma regcall(display_text_centered(d0,d1,d2,d3,a0,d4))
VOID change_fkey_text(VOID);

	/* display2.c */

BYTE   *get_input(USHORT mode, BYTE *default_string);
#pragma regcall(get_input(d0,a0))
USHORT get_answer(USHORT mode, BYTE *text, USHORT default_answer);
#pragma regcall(get_answer(d0,a0,d1))
VOID   print_dir_info(struct FileRequest  *freq);
#pragma regcall(print_dir_info(a0))
VOID   refresh_dir_info(struct FileRequest  *freq);
#pragma regcall(refresh_dir_info(a0))
VOID   print_about_page(VOID);
VOID   refresh_about_page(VOID);
BOOL   print_help_page(USHORT page_num);
#pragma regcall(print_help_page(d0))
BOOL   refresh_help_page(USHORT page_num);
#pragma regcall(refresh_help_page(d0))

	/* dos1.c */

VOID  action_copy(VOID);
SHORT copy_single(struct FileRequest  *freq, struct FileNode  *fnode,
							    BYTE *dest_ptr);
#pragma regcall(copy_single(a0,a1,a2))
SHORT copy_multi(struct FileRequest  *freq, struct FileNode  *fnode,
							    BYTE *dest_ptr);
#pragma regcall(copy_multi(a0,a1,a2))
SHORT copy_file(BPTR source_lock, BYTE *source, BYTE *dest);
#pragma regcall(copy_file(a0,a1,a2))
SHORT do_copy_file(BYTE *source, BYTE *dest,
					 struct FileInfoBlock  *source_fib);
#pragma regcall(do_copy_file(a0,a1,a2))
SHORT clone_file_info_block(BYTE *path, struct FileInfoBlock  *fib);
#pragma regcall(clone_file_info_block(a0,a1))
VOID  action_rename_move(VOID);
SHORT rename_move_single(struct FileRequest  *freq, struct FileNode  *fnode,
							    BYTE *dest_ptr);
#pragma regcall(rename_move_single(a0,a1,a2))
SHORT rename_move_multi(struct FileRequest  *freq, struct FileNode  *fnode,
							    BYTE *dest_ptr);
#pragma regcall(rename_move_multi(a0,a1,a2))
SHORT rename_file(BYTE *source, BYTE *dest);
#pragma regcall(rename_file(a0,a1))

	/* dos2.c */

VOID  action_make_dir(VOID);
SHORT make_dir(BYTE *dir_name);
#pragma regcall(make_dir(a0))
VOID  action_delete(VOID);
SHORT delete_file(struct FileRequest  *freq, struct FileNode  *fnode);
#pragma regcall(delete_file(a0,a1))
SHORT do_delete_file(BYTE *path, LONG protection);
#pragma regcall(do_delete_file(a0,d0))
SHORT get_dos_error(SHORT error);
#pragma regcall(get_dos_error(d0))
VOID  get_current_dir(VOID);
SHORT change_current_dir(VOID);

	/* history.c */

VOID  action_history(VOID);
VOID  print_history_page(struct HistoryRequest  *hreq);
#pragma regcall(print_history_page(a0))
SHORT read_history(struct HistoryRequest  *hreq);
#pragma regcall(read_history(a0))
VOID  jump_to_history_line(struct HistoryRequest  *hreq);
#pragma regcall(jump_to_history_line(a0))
VOID  search_history_line(struct HistoryRequest  *hreq, USHORT mode);
#pragma regcall(search_history_line(a0,d0))
VOID  print_history_text(struct HistoryRequest  *hreq, USHORT mode);
#pragma regcall(print_history_text(a0,d0))
BYTE  *get_history_line(struct HistoryRequest  *hreq);
#pragma regcall(get_history_line(a0))
struct LineNode  *get_history_node_under_cursor(struct HistoryRequest  *hreq);
#pragma regcall(get_history_node_under_cursor(a0))
VOID  move_hreq_cursor(struct HistoryRequest  *hreq, struct LineNode  *lnode);
#pragma regcall(move_hreq_cursor(a0,a1))

	/* main_segment.c */

VOID _main(VOID);
VOID alloc_buffers(VOID);

	/* subs.c */

BPTR  quiet_lock(BYTE *name, LONG mode);
#pragma regcall(quiet_lock(a0,d0))
SHORT quiet_examine(BPTR lock, struct FileInfoBlock  *fib);
#pragma regcall(quiet_examine(a0,a1))
SHORT check_for_dir(BYTE *dir);
#pragma regcall(check_for_dir(a0))
SHORT check_for_load_file(BYTE *file);
#pragma regcall(check_for_load_file(a0))
SHORT read_new_dir(struct FileRequest  *freq, BYTE *dir, USHORT mode);
#pragma regcall(read_new_dir(a0,a1,d0))
SHORT read_same_dir(struct FileRequest  *freq, USHORT mode);
#pragma regcall(read_same_dir(a0,d0))
SHORT new_dir(struct FileRequest  *freq, BYTE *dir);
#pragma regcall(new_dir(a0,a1))
SHORT read_dir(struct FileRequest  *freq);
#pragma regcall(read_dir(a0))
SHORT get_dir_info(struct FileRequest  *freq);
#pragma regcall(get_dir_info(a0))
VOID  free_dir(struct FileRequest  *freq);
#pragma regcall(free_dir(a0))
VOID  free_list(struct MinList  *list, ULONG node_size);
#pragma regcall(free_list(a0,d0))
SHORT build_path_name_from_lock(BYTE *buffer, BPTR lock);
#pragma regcall(build_path_name_from_lock(a0,a1))
VOID  build_path_name_from_file_node(BYTE *buffer,
			struct FileRequest  *freq, struct FileNode  *fnode);
#pragma regcall(build_path_name_from_file_node(a0,a1,a2))
SHORT build_path_name_from_relative_path(BYTE *buffer, BYTE *path);
#pragma regcall(build_path_name_from_relative_path(a0,a1))
BYTE  *append_path_name(BYTE *buffer, struct FileRequest  *freq,
				      struct FileNode  *fnode, USHORT mode);
#pragma regcall(append_path_name(a0,a1,a2,d0))
BYTE  *append_base_name(BYTE *buffer, struct FileNode  *fnode);
#pragma regcall(append_base_name(a0,a1))
SHORT build_device_name(BYTE *buffer, BPTR lock);
#pragma regcall(build_device_name(a0,a1))
SHORT read_devs(struct FileRequest  *freq);
#pragma regcall(read_devs(a0))
struct FileNode  *get_file_node_under_cursor(struct FileRequest  *freq);
#pragma regcall(get_file_node_under_cursor(a0))
struct FileNode  *remove_file_node(struct FileRequest  *freq,
						   struct FileNode  *fnode);
#pragma regcall(remove_file_node(a0,a1))
VOID  rename_file_node(struct FileRequest  *freq, struct FileNode  *fnode,
								BYTE *name);
#pragma regcall(rename_file_node(a0,a1,a2))
SHORT duplicate_file_list(struct FileRequest  *freq1,
						struct FileRequest  *freq2);
#pragma regcall(duplicate_file_list(a0,a1))
VOID  duplicate_marks(struct FileRequest  *freq, struct MinList  *list,
						      ULONG marked_entries);
#pragma regcall(duplicate_marks(a0,a1,d0))
VOID  duplicate_cursor_line(struct FileRequest  *freq, BYTE *name,
					      ULONG pos, SHORT cursor_line);
#pragma regcall(duplicate_cursor_line(a0,a1,d0,d1))
VOID  restore_old_cursor_line(struct FileRequest  *freq, BYTE *name,
					      ULONG pos, SHORT cursor_line);
#pragma regcall(restore_old_cursor_line(a0,a1,d0,d1))
VOID  jump_to_freq_entry(BYTE *name, USHORT mode);
VOID  move_freq_cursor(struct FileRequest  *freq, struct FileNode  *fnode,
							       USHORT mode);
#pragma regcall(move_freq_cursor(a0,a1,d0))
#pragma regcall(jump_to_freq_entry(a0,d0))
SHORT check_date_stamp(struct FileRequest  *freq, USHORT mode);
#pragma regcall(check_date_stamp(a0,d0))
SHORT set_date_stamp(struct FileRequest  *freq);
#pragma regcall(set_date_stamp(a0))
SHORT execute(BYTE *prog, BYTE *args);
#pragma regcall(execute(a0,a1))
SHORT find(struct FileRequest  *freq, BYTE *pattern);
#pragma regcall(find(a0,a1))
VOID  clear_input_line(VOID);
SHORT force_string(BYTE *string, USHORT len, USHORT mode);
#pragma regcall(force_string(a0,d0,d1))

	/* tree.c */

VOID  action_tree(VOID);
VOID  print_tree_page(struct TreeRequest  *treq);
#pragma regcall(print_tree_page(a0))
SHORT build_dir_tree(struct TreeRequest  *treq, BYTE *dev_name);
#pragma regcall(build_dir_tree(a0,a1))
SHORT read_tree_dirs(struct TreeRequest  *treq,
					    struct TreeNode  *parent_tnode);
#pragma regcall(read_tree_dirs(a0,a1))
struct TreeNode  *get_next_unscanned_tree_node(struct TreeRequest *treq,
					    struct TreeNode  *parent_tnode);
#pragma regcall(get_next_unscanned_tree_node(a0,a1))
VOID  free_dir_tree(struct TreeRequest  *treq);
#pragma regcall(free_dir_tree(a0))
VOID  scroll_tree_req(VOID);
BYTE  *build_tnode_path_name(struct TreeRequest  *treq,
					    struct TreeNode  *search_tnode);
#pragma regcall(build_tnode_path_name(a0,a1))
VOID  jump_to_treq_entry(BYTE *name, USHORT mode);
#pragma regcall(jump_to_treq_entry(a0,d0))
VOID  move_treq_cursor(struct TreeRequest  *treq, struct TreeNode  *tnode,
								USHORT mode);
#pragma regcall(move_treq_cursor(a0,a1,d0))
struct TreeNode	 *get_tree_node_by_name(struct TreeRequest  *treq,
				       struct TreeNode  *tnode, BYTE *name);
#pragma regcall(get_tree_node_by_name(a0,a1,a2))

	/* view.c */

VOID  action_view(VOID);
SHORT view_file(struct FileRequest  *freq, struct FileNode  *fnode);
#pragma regcall(view_file(a0,a1))
VOID  print_view_page(struct ViewRequest  *vreq);
#pragma regcall(print_view_page(a0))
SHORT read_view_file(struct FileRequest  *freq, struct FileNode  *fnode,
						 struct ViewRequest  *vreq);
#pragma regcall(read_view_file(a0,a1,a2))
VOID  jump_to_view_line(struct ViewRequest  *vreq);
#pragma regcall(jump_to_view_line(a0))
VOID  search_view_line(struct ViewRequest  *vreq, USHORT mode);
#pragma regcall(search_view_line(a0,d0))
VOID  mark_search_view_lines(struct ViewRequest  *vreq,
			 struct LineNode  *lnode, BYTE *string, USHORT len);
#pragma regcall(mark_search_view_lines(a0,a1,a2,d0))
SHORT change_view_mode(struct ViewRequest  *vreq);
#pragma regcall(change_view_mode(a0))
VOID  print_view_text(struct ViewRequest  *vreq, USHORT mode);
#pragma regcall(print_view_text(a0,d0))
VOID  print_quick_view(struct FileRequest  *freq);
#pragma regcall(print_quick_view(a0))