/*
**		BRIEF -- Basic Reconfigurable Interactive Editing Facility
**
**		Written by Dave Nanian and Michael Strickman.
*/

/*
**		compile.cb:
**
**		This file contains all of the standard BRIEF macros for compiling
**	files.
*/

string add_to_path (string path, string name);
string escape_re (string original, ~string);
int next_error (~int action);
int cc (string pass_string, ~string legal_extension, ~int check_warnings, ~int background, ~int continuation);
void _cc_complete (int ret_code, string full_name, int check_warnings, string pass_string);
int cm (...);
int cb (...);

extern int	_check_warnings,	//	Check for warnings in the compiler output?
				_background;		//	Run the compiler in the background?

/*
**		compile_it:
**
**		This function automatically compiles the file in the current
**	buffer.	It uses the "BC<extension>" environment variable to
**	determine what to do with any given file.  If no "BC<extension>"
**	environment variable exists for the specific file extension being
**	compiled, compile_it checks to see if it's ".c", ".m" or ".asm".	If
**	it's a macro file the "cm" macro is executed; if it's a C file, a
**	generic "cc" command is used, and if it's an ASM file, the Macro
**	Assembler is invoked.
**
**		Other compilers can be supported very easily.  Simply set a
**	"BC<extension>" environment variable to the "pass string" you
**	want to use.  For example, if you wanted to call the (fictitious)
**	UnderWare C compiler, which has two passes called "under" and "ware",
**	you'd use the command:
**
**		set bcc="under %s;ware %s"
**
**		You must place the pass string in quotes.  If you don't, compile_it
**	calls a macro named whatever is in the pass string.  So, for example,
**	if you accidently set your pass string using the command:
**
**		set bcc=under %s;ware %s
**
**		compile_it would call a macro named "under %s;ware %s".	This probably
**	isn't what you want -- but this feature can be useful if you want to
**	run some sort of custom macro for the file extension (compile_it does
**	this when compiling cm files).
**
**		Also note that DOS requires you to double any % characters that
**	appear in a batch file.  So if you were setting the BCC variable in
**	your autoexec, you would use the line:
**
**		set bcc="under %%s;ware %%s"
**
**		Each pass begins with the name of the executable program that does
**	that compilation pass.	That is followed by the a space, the special
**	string "%s", which is replaced by the filename (with NO extension),
**	and the multiple pass separation character ";".  If you want to put
**	a ";" in your pass string, use "\;".
**
**		These special characters are very important -- don't forget them!
**	Remember that the special "%s" string is only replaced by the filename,
**	not the filename and the extension.  Up to seven of these can be specified
**	in any given pass.  If your compiler requires the extension as well,
**	place it after this string (e.g. "cc -c %s.c").
**
**		If you want to pass options to your compiler, you can place them
**	either before or after the "%s".  Placing them before puts the option
**	before the filename, and vice versa.
**
**		If your compiler doesn't return an error code, put an exclamation
**	point in front of the first pass string (either inside or outside the
**	quotes); this will override the current warnings_only setting and
**	automatically check for errors in the compiler output.
*/

int compile_it (void)
{
	string	extension,		//	File extension of the current file.
				command;			//	Command to be used to compile file.

	inq_names (NULL, extension);
	command = trim (ltrim (inq_environment ("BC" + upper (extension))));

	if (command != "")
		{
		if (index (command, "\""))
			{
			int	loc,
					background;

			background = _background;

			while (loc = index (command, "\""))
				command = substr (command, 1, loc - 1) + substr (command, loc + 1);

			if (substr (command, strlen (command), 1) == "&")
				{
				background = 1;
				command = trim (substr (command, 1, strlen (command) - 1));
				}
			if ("!" == substr (command, 1, 1))
				returns (cc (substr (command, 2), extension, 1, background));
			else
				returns (cc (command, extension, NULL, background));
			}
		else
			{
			int	check_warnings = _check_warnings;

			if (substr (command, 1, 1) == "!")
				{
				check_warnings = 1;
				command = substr (command, 2);
				}
			returns (execute_macro (command, command, check_warnings));
			}
		}
	else
		switch (extension)
			{
			case "m":
				returns (cm (_check_warnings));

			case "asm":
				returns (cc ("masm %s\\;", extension));

			case "c":
				returns (cc ("cc -c %s.c", extension));

			case "cb":
				returns (cb (_check_warnings));

			default:
				{
				error ("Can't compile: no BC%s environment variable.", upper (extension));
				returns (-1);
				}
			}
}

/*
**		warnings_only:
**
**		This macro toggles whether or not errors are searched for when a
**	compile is done and the compiler returns "no errors".  Note that its
**	value is saved in the state file.
*/

int warnings_only (~int)
{
	int	ret_code,
			previous_value;

	previous_value = _check_warnings;

	if (!(ret_code = get_parm (0, _check_warnings)))
		_check_warnings = !_check_warnings;

	if (!ret_code || inq_called () == "")
		message ("Compile warning detection %s.", _check_warnings ? "on" : "off");

	returns (previous_value);
}

/*
**		bgd_compilation:
**
**		This macro toggles whether or not compilation is done in the
**	background under operating systems that support it.  Note that this
**	value is saved in the state file.
*/

int bgd_compilation (~int)
{
	int	ret_code,
			previous_value;

	previous_value = _background;

	if (!(ret_code = get_parm (0, _background)))
		_background = !_background;

	if (!ret_code || inq_called () == "")
		message ("Background compilation %s.", _background ? "on" : "off");

	returns (previous_value);
}

/*
**		cc:
**
**		This routine compiles the file in the current buffer using the
**	passed "pass string" and the BRIEF DOS command.  It needs a lot
**	of memory to run -- either turn swapping on or start with at least
**	256K and -M20.  Of course, this may vary depending with the size
**	and memory requirements of the specific compiler you're using.
**
**		The "pass string" passed should be of the form:
**
**			pass_1 %s;pass_2 %s;...pass_n %s
**
**		The optional second parameter is an extended file type -- this is
**	used by the "cm" and "cb" macros, and to compile other types of files
**	(e.g. .asm).
**
**		If no pass string is specified, it defaults to a generic "cc"
**	command.  If no extension is specified, it defaults to "c".
*/

int cc (string pass_string, ~string, ~int, ~int, ~int continuation)
{
	string	file_name,			//	The name of the file we're compiling.
				legal_extension,	//	The extension of files we can compile.
				path,					//	The path of the file we're compiling.
				extension,			//	The extension of the file we're compiling.
				command_line, 		//	The compile command line.
				old_path,			//	The original path we were on.
				error_file;			//	The file to put error information in.

	int	loc, 						//	Generic index place holder.
			length, 					//	Generic length place holder.
			ret_code = 1,			//	Return code from DOS.
			buffer_id, 				//	Buffer ID of error buffer.
			check_warnings,		//	Examine result of compile for errors?
			background;				//	Do compilation in background?

	/*
	**		We get the name of the file from inq_names and check to see
	**	if it's a legal extension.
	*/

	if (!get_parm (1, legal_extension))
		legal_extension = "c";

	inq_names (path, extension, file_name);

	if (extension != legal_extension)
		error ("Current buffer is not a .%s file.", legal_extension);
	else
		{
		/*
		**		If the file has been modified, we want to make sure the
		**	current version gets compiled, so we write it to disk.
		**
		**		Note that if the user does not specify a pass string, it
		**	defaults to a generic "cc" command.
		*/

		if (pass_string == "")
			pass_string = "cc -c %s.c";

		if (!get_parm (2, check_warnings))
			check_warnings = _check_warnings;

		if (!get_parm (3, background))
			background = _background;

		version (old_path);

		if (old_path != "OS/2")
			background = 0;

		if (!continuation && inq_modified ())
			{
			int	old_msg_level;

			old_msg_level = inq_msg_level ();
			set_msg_level (0);
			ret_code = write_buffer ();
			set_msg_level (old_msg_level);
			}

		if (ret_code > 0)
			{
			/*
			**		Now we parse the filename off the path string,
			**	making sure to handle the possible presence of forward
			**	and backward slash characters.  We then replace the
			**	file_name's ".c" with ".err" for redirection purposes.
			*/

			path = substr (path, 1, rindex (path, substr (path, 3, 1)));

			if (strlen (path) > 3)
				path = substr (path, 1, strlen (path) - 1);

			file_name = substr (file_name, 1, index (file_name, ".") - 1);
			error_file = file_name + ".err";
			ret_code = 0;

			/*
			**		We want the .obj file to end up in the file's
			**	directory, so we change to the directory where the
			**	file is, saving the current directory.  We also make
			**	the file's drive the default drive.
			*/

			getwd ("", command_line);
			getwd (path, old_path);
			old_path = substr (command_line, 1, 1) + substr (old_path, 2);
			cd (path);
			cd (substr (path, 1, 2));

			/*
			**		This loop goes through each pass of the compiler,
			**	checks to see if the return code was OK, and, if so,
			**	continues along.	If an error occurs, the loop exits
			**	immediately.
			*/

			while (!ret_code && strlen (pass_string))
				{
				if (loc = search_string ("[~\\\\];", pass_string))
					{
					command_line = substr (pass_string, 1, loc);
					pass_string = substr (pass_string, loc + 2);
					}
				else
					{
					command_line = pass_string;
					pass_string = "";
					}
				command_line += " >&" + error_file;

				while (loc = index (command_line, "\\;"))
					command_line = substr (command_line, 1, loc - 1) + substr (command_line, loc + 1);

				/*
				**		Since environment variables don't allow "=" characters to
				**	appear in them, we use "--" as an alias.
				*/

				while (loc = index (command_line, "--"))
					command_line = substr (command_line, 1, loc - 1) + "=" + substr (command_line, loc + 2);

				sprintf (command_line, command_line, file_name, file_name, file_name, file_name, file_name, file_name, file_name);
				message ("%s", background ? command_line + " &" : command_line);

				if (background)
					{
					string completion_rtn;

					inq_names (file_name);
					sprintf (completion_rtn, "_cc_complete \"%s\" %d \"%s\"", file_name, check_warnings, escape_re (pass_string, "\""));
					dos (command_line, 0, completion_rtn);
					break;
					}
				else if ((ret_code = dos (command_line, 0)) > 0)
					next_error ();
				else if (ret_code == 0 && check_warnings)
					ret_code = next_error (2);
				}
			/*
			** 		Finally, we restore the old directory.  If the
			** 	compilation did not succeed, the next_error macro
			** 	was called to place the cursor under the error.
			**
			** 		Otherwise, the temporary file is deleted and a
			** 	message is printed.
			*/

			if (!background && ret_code <= 0)
				{
				del (error_file);

				if (ret_code == 0)
					message ("Compilation successful.");
				}
			cd (substr (old_path, 3));
			cd (substr (old_path, 1, 2));
			}
		}
	returns (ret_code);
}

/*
**		_cc_complete:
**
**		This is the completion routine for background compilation.
*/

void _cc_complete (int ret_code, string full_name, int check_warnings, string pass_string)
{
	int	in_memory,
			old_buf_id = inq_buffer (),
			buf_id,
			loc;

	string	file_name,
				extension;

	/*
	**		First, we check to see if the buffer being compiled
	**	is in the buffer list.
	*/

	in_memory = (inq_buffer (full_name) != 0);

	/*
	**		If in_memory is true then the current buffer is set
	**	to the buffer we're compiling.	Otherwise, we have to
	**	read it into memory to prepare for a possible next_error.
	*/

	loc = strlen (full_name);

	while (!index ("/\\", substr (full_name, loc, 1)))
		--loc;

	file_name = substr (full_name, loc + 1);

	if (!in_memory)
		if (buf_id = create_buffer (file_name, full_name))
			set_buffer (buf_id);
		else
			error ("_cc_complete:  fatal error, can't edit %s.", file_name);

	inq_names (NULL, extension);

	if (!ret_code)
		{
		if (check_warnings)
			ret_code = next_error (3);

		if (!ret_code)
			if (pass_string == "")
				{
				message ("Compilation of %s successful.", file_name);
				del (substr (full_name, 1, rindex (full_name, ".")) + "err");
				}
			else
				cc (pass_string, extension, check_warnings, 1, 1);
		}
	/*
	** 	At this point, we know we can clean up.  First, we set
	**	the current buffer to the one we started with.	Then, if we
	**	temporarily edited the buffer we were compiling, we delete
	**	it.
	*/

	set_buffer (old_buf_id);

	if (!in_memory)
		delete_buffer (buf_id);

	if (ret_code)
		{
		beep ();

		if (buf_id == 0 || old_buf_id == buf_id)
			error ("Error compiling %s; press %s.", file_name, inq_assignment ("next_error", 1));
		else
			error ("Error compiling %s.", file_name, inq_assignment ("next_error", 1));
		}
}

/*
** 	cm:
**
** 	This macro compiles the macro in the current buffer (if there is one).
**	If the compilation was successful, the macro is re-loaded (or loaded, as
**	the case may be).  If the compilation failed, the errorfix macro
**	is used to locate the problem in the .m file.
**
** 	Note that the "cc" macro is used to do most of the work.  This macro
**	merely calls "cc" with the parameters required for compilation of a
**	macro file, then loads the file if the compilation was successful.
*/

int cm (...)
{
	int	check_warnings,
			curr_parm,
			ret_code;

	string	command_line = "cm";

	for (curr_parm = 1 ; curr_parm >= 0 && !get_parm (curr_parm, check_warnings) ; curr_parm--);

	if (curr_parm > 0)
		get_parm (0, command_line);

	command_line += " %s";

	if (!(ret_code = cc (command_line, "m", check_warnings, 0)))
		{
		int	old_msg_level;

		string	name;

		inq_names (name);
		name = substr (name, 1, rindex (name, ".") - 1);
		old_msg_level = inq_msg_level ();
		set_msg_level (3);
		delete_macro (name);
		set_msg_level (old_msg_level);
		load_macro (name);
		message ("Macro compiled and loaded.");
		}
	returns (ret_code);
}

/*
** 	cb:
**
** 	This macro compiles the CBRIEF macro in the current buffer (if
**	there is one).  If the compilation was successful, the macro is
**	re-loaded (or loaded, as the case may be).  If the compilation failed,
**	the errorfix macro is used to locate the problem in the .m file.
**
** 	Note that the "cc" macro is used to do most of the work.  This macro
**	merely calls "cc" with the parameters required for compilation of a
**	CBRIEF file, then loads the file if the compilation was successful.
*/

int cb (...)
{
	int	check_warnings,
			curr_parm,
			ret_code;

	string	command_line = "cb";

	for (curr_parm = 1 ; curr_parm >= 0 && !get_parm (curr_parm, check_warnings) ; curr_parm--);

	if (curr_parm > 0)
		get_parm (0, command_line);

	command_line += " %s";

	if (!(ret_code = cc (command_line, "cb", check_warnings, 0)))
		{
		int	old_msg_level;

		string	name;

		inq_names (name);
		name = substr (name, 1, rindex (name, ".") - 1);
		old_msg_level = inq_msg_level ();
		set_msg_level (3);
		delete_macro (name);
		set_msg_level (old_msg_level);
		load_macro (name);
		message ("Macro compiled and loaded.");
		}
	returns (ret_code);
}