blib_db.c

smallbasic for linux

/*
*	SmallBasic LIBRARY - FILE I/O
*
*	2000-05-27, Nicholas Christopoulos
*
*	This program is distributed under the terms of the GPL v2.0 or later
*	Download the GNU Public License (GPL) from www.gnu.org
*/

#include "sys.h"
#include "kw.h"
#include "var.h"
#include "pproc.h"
#include "device.h"
#include "blib.h"

/*
*	OPEN "file" [FOR {INPUT|OUTPUT|APPEND}] AS #fileN
*/
void	cmd_fopen()
{
	var_t	file_name;
	int		flags = 0;
	int		handle;

	// filename
	par_getstr(&file_name);		if ( prog_error )	return;

	// mode
	if	( code_peek() == kwFORSEP )	{
		code_skipnext();
		switch ( code_peek() )	{
		case	kwINPUTSEP:
			flags = DEV_FILE_INPUT;
			break;
		case	kwOUTPUT:
			flags = DEV_FILE_OUTPUT;
			break;
		case	kwAPPEND:
			flags = DEV_FILE_APPEND;
			break;
		default:
			err_syntax();
			v_free(&file_name);
			return;
			}

		code_skipnext();
		}
	else
		flags = 0;	// ????

	// file handle
	if	( code_peek() == kwAS )	{
		code_skipnext();

		par_getsharp();
		if	( !prog_error )	{
			handle = par_getint();
			if	( !prog_error )	{
				if	( dev_fstatus(handle) == 0 )	
					dev_fopen(handle, file_name.ptr, flags);
				else
					rt_raise("OPEN: FILE IS ALREADY OPENED");
				}
			}
		}
	else
		err_syntax();

	v_free(&file_name);
}

/*
*	CLOSE #fileN
*/
void	cmd_fclose()
{
	int		handle;

	// file handle
	par_getsharp();
	if	( !prog_error )	{
		handle = par_getint();
		if	( !prog_error )	{
			if	( dev_fstatus(handle) )
				dev_fclose(handle);
			else
				rt_raise("CLOSE: FILE IS NOT OPENED");
			}
		}
}

/*
*	SEEK #fileN, pos
*/
void	cmd_fseek()
{
	int		handle;
	dword	pos;

	// file handle
	par_getsharp();
	if	( !prog_error )	{
		handle = par_getint();
		if	( !prog_error )	{
			if	( dev_fstatus(handle) )	{
				par_getsep();
				if	( !prog_error )	{
					pos = par_getint();
					if	( !prog_error )	{
						dev_fseek(handle, pos);
						}
					}
				}
			else
				rt_raise("SEEK: FILE IS NOT OPENED");
			}
		}
}

/*
*	PRINT #fileN; var1 [, varN]
*/
void	cmd_fprint()
{
	int		handle;
	char	buf[64];

	// file handle
	par_getsharp();
	if	( !prog_error )	{
		handle = par_getint();
		if	( !prog_error )	{

			if	( code_peek() == kwTYPE_EOC || code_peek() == kwTYPE_LINE )	{	// There are no parameters
				if	( dev_fstatus(handle) )	
					dev_fwrite(handle, "\n", 1);
				else
					rt_raise("FIO: FILE IS NOT OPENED");
				return;
				}

//			par_getsemicolon();
			par_getsep();			// allow commas

			if	( !prog_error )	{

				if	( dev_fstatus(handle) )	{

					byte	code, last_op = 0, exitf = 0;
					var_t	var;

					do	{
						code = code_peek();
						switch ( code )	{
						case	kwTYPE_LINE:
						case	kwTYPE_EOC:
							exitf = 1;
							break;
						case	kwTYPE_SEP:
							code_skipnext();
							last_op = code_getnext();
							if	( last_op == ',' )
								dev_fwrite(handle, "\t", 1);
							break;
						default:
							last_op = 0;
							v_init(&var);
							eval(&var);
							if	( !prog_error )	{
								switch ( var.type )	{
								case V_STR:
									dev_fwrite(handle, var.ptr, strlen(var.ptr));
									v_free(&var);
									break;
								case V_INT:
									ltostr(var.i, buf);
									dev_fwrite(handle, buf, strlen(buf));
									break;
								case V_NUM:
									ftostr(var.n, buf);
									dev_fwrite(handle, buf, strlen(buf));
									}
								}

							};

						if	( prog_error )
							return;
						} while ( exitf == 0 );

					if	( last_op == 0 )
						dev_fwrite(handle, "\n", 1);
					}
				else
					rt_raise("FIO: FILE IS NOT OPENED");
				}
			}
		}
}

/*
*	LINEINPUT #fileN; var$
*/
void	cmd_flineinput()
{
	int		handle, size, index;
	var_t	*var_p;
	byte	code, ch;

	// file handle
	par_getsharp();
	if	( !prog_error )	{
		handle = par_getint();
		if	( !prog_error )	{
			// par_getsemicolon();
			par_getsep();			// allow commas

			if	( !prog_error )	{

				if	( dev_fstatus(handle) )	{

					// get the variable
					code = code_peek();
					if	( code != kwTYPE_VAR )	{
						err_syntax();
						return;
						}
					code_skipnext();
					var_p = code_getvarptr();
		
					if	( !prog_error )	{
						v_free(var_p);
						size = 256;
						index = 0;
						var_p->type = V_STR;
						var_p->ptr = tmp_alloc(size);

						// READ IT
						while ( !dev_feof(handle) )	{
							dev_fread(handle, &ch, 1);
							if	( prog_error )	{
								var_p->type = V_INT;
								var_p->i = -1;
								tmp_free(var_p->ptr);
								var_p->ptr = NULL;
								return;
								}
							else if	( ch == '\n' )
								break;
							else if	( ch != '\r' )	{
								// store char
								if	( index == (size-1) )	{
									size += 256;
									var_p->ptr = tmp_realloc(var_p->ptr, size);
									}
								var_p->ptr[index] = ch;
								index ++;
								}
							}
					
						//
						var_p->ptr[index] = '\0';
						var_p->size = index+1;

						} // read
					else
						rt_raise("FIO: FILE IS NOT OPENED");
					}
				}
			}
		}
}

/*
*	INPUT #fileN; var$ [, var2 [, ...]]
*/
void	cmd_finput()
{
	int		handle, size, index;
	var_t	*var_p;
	byte	code, ch;
	int		type;
	long	lv;
	double	dv;
	char	buf[64], *np;

	// file handle
	par_getsharp();
	if	( !prog_error )	{
		handle = par_getint();
		if	( !prog_error )	{
			// par_getsemicolon();
			par_getsep();			// allow commas

			if	( !prog_error )	{

				if	( dev_fstatus(handle) )	{

					// get the variable
					do	{

						if	( prog_error )	
							break;

						// get variable's ptr
						code = code_peek();
						if	( code != kwTYPE_VAR )	{
							err_syntax();
							return;
							}
						code_skipnext();
						var_p = code_getvarptr();
		
						if	( !prog_error )	{
							v_free(var_p);
							size = 256;
							index = 0;
							var_p->type = V_STR;
							var_p->ptr = tmp_alloc(size);

							// READ IT
							while ( !dev_feof(handle) )	{
								dev_fread(handle, &ch, 1);
								if	( prog_error )	{
									var_p->type = V_INT;
									var_p->i = -1;
									tmp_free(var_p->ptr);
									var_p->ptr = NULL;
									return;
									}
								else if	( ch == '\n' || ch == ',' )
									break;
								else if	( ch != '\r' )	{
									// store char
									if	( index == (size-1) )	{
										size += 256;
										var_p->ptr = tmp_realloc(var_p->ptr, size);
										}
									var_p->ptr[index] = ch;
									index ++;
									}
								} // while read
					
							//
							var_p->ptr[index] = '\0';
							var_p->size = index+1;

							// 
							np = get_numexpr(var_p->ptr, buf, &type, &lv, &dv);

							if	( type == 1 && *np == '\0' )	{
								var_p->type = V_INT;
								var_p->i = lv;
								tmp_free(var_p->ptr);
								var_p->ptr = NULL;
								var_p->size = 0;
								}
							else if	( type == 2  && *np == '\0' )	{
								var_p->type = V_NUM;
								var_p->n = dv;
								tmp_free(var_p->ptr);
								var_p->ptr = NULL;
								var_p->size = 0;
								}

							// next
							code = code_peek();
							if	( code == kwTYPE_SEP )	
								par_getsep();			// allow commas
							else
								break;

							} // read (!prog_error)

						} while ( 1 );

					}
				else
					rt_raise("FIO: FILE IS NOT OPENED");
				}
			}
		}
}

/*
*	KILL filename
*/
void	cmd_fkill()
{
	var_t	file_name;

	// filename
	v_init(&file_name);
	par_getstr(&file_name);		if ( prog_error )	return;
	if	( dev_fexists(file_name.ptr) )	
		dev_fremove(file_name.ptr);
	else
		rt_raise("KILL: FILE DOES NOT EXIST");
	v_free(&file_name);
}

/*
*	COPY/RENAME filem newfile
*/
void	cmd_filecp(int mv)
{
	var_t	src, dst;

	// filename
	v_init(&src);
	v_init(&dst);
	par_getstr(&src);		if ( prog_error )	return;
	par_getcomma();			if ( prog_error )	{ v_free(&src); return; }
	par_getstr(&dst);		if ( prog_error )	{ v_free(&src); return; }

	if	( dev_fexists(src.ptr) )	{
		if	( !mv )
			dev_fcopy(src.ptr, dst.ptr);
		else
			dev_frename(src.ptr, dst.ptr);
		}
	else
		rt_raise("COPY/RENAME: FILE DOES NOT EXIST");

	v_free(&src);
	v_free(&dst);
}