blib_func.c

来自「smallbasic for linux」· C语言 代码 · 共 1,181 行 · 第 1/2 页

	case kwINKEY:
		//
		// str <- INKEY$
		//
		if	( dev_kbhit() )	{
			ch = dev_getch();	// MultiByte - dev_getchr() must return the extended code (2 bytes char)
			if	( (ch & 0xFF00) == 0xFF00 )	{	// extra code - hardware keys
				tmp[0] = '\033';
				tmp[1] = ch & 0xFF;
				tmp[2] = '\0';
				}
			else	{
				switch ( os_charset )	{
				case	enc_sjis:				// Japan
					if	( IsJISFont(ch) )	{
						tmp[0] = ch >> 8;
						tmp[1] = ch & 0xFF;
						tmp[2] = '\0';
						}
					else	{
						tmp[0] = ch;
						tmp[1] = '\0';
						}
					break;

				case	enc_big5:				// China
					if	( IsBig5Font(ch) )	{
						tmp[0] = ch >> 8;
						tmp[1] = ch & 0xFF;
						tmp[2] = '\0';
						}
					else	{
						tmp[0] = ch;
						tmp[1] = '\0';
						}
					break;

				case	enc_gmb:				// Generic multibyte
					if	( IsGMBFont(ch) )	{
						tmp[0] = ch >> 8;
						tmp[1] = ch & 0xFF;
						tmp[2] = '\0';
						}
					else	{
						tmp[0] = ch;
						tmp[1] = '\0';
						}
					break;

				case	enc_unicode: 			// Unicode
					tmp[0] = ch >> 8;
					tmp[1] = ch & 0xFF;
					tmp[2] = '\0';
					break;

				default:						// Europe 8bit
					tmp[0] = ch;
					tmp[1] = '\0';
					};
				}

			v_createstr(r, tmp);
			}
		else
			v_createstr(r, "");
		break;
	case kwDATE:
		//
		//	str <- DATE$
		//
		#if defined(_PalmOS)
		dts = TimGetSeconds();
		TimSecondsToDateTime(dts, &cur_date);

		r->type = V_STR;
		r->ptr = tmp_alloc(32);
		r->size = 32;
		StrPrintF(r->ptr, "%02d/%02d/%04d", cur_date.day, cur_date.month, cur_date.year);
		#else
		time(&now);
		tms = *localtime(&now);
		r->type = V_STR;
		r->ptr = tmp_alloc(32);
		r->size = 32;
		sprintf(r->ptr, "%02d/%02d/%04d", tms.tm_mday, tms.tm_mon+1, tms.tm_year+1900);
		#endif
		break;
	case kwTIME:
		//
		//	str <- TIME$
		//
		#if defined(_PalmOS)
		dts = TimGetSeconds();
		TimSecondsToDateTime(dts, &cur_date);

		r->type = V_STR;
		r->ptr = tmp_alloc(32);
		r->size = 32;

		StrPrintF(r->ptr, "%02d:%02d:%02d", cur_date.hour, cur_date.minute, cur_date.second);
		#else
		time(&now);
		tms = *localtime(&now);
		r->type = V_STR;
		r->ptr = tmp_alloc(32);
		r->size = 32;
		sprintf(r->ptr, "%02d:%02d:%02d", tms.tm_hour, tms.tm_min, tms.tm_sec);
		#endif
		break;
		}
}

//
//	str <- FUNC (...)
//
void	cmd_strN(byte funcCode, var_t *r)
{
	var_t	arg1, arg2, arg3;
	int		i, count, lsrc, len, start;
	char	tmp[2], *tmp_p;

	v_init(&arg1);
	v_init(&arg2);
	v_init(&arg3);

	if	( prog_error )	return;
	switch ( funcCode )	{
	case kwSTRING:
		//
		// str <- STRING$ ( int, int | str )
		//
		count = par_getint();
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error )	{
				par_getvar(&arg2);
				if	( !prog_error )	{

					if	( arg2.type == V_STR )	{
						len = strlen(arg2.ptr);
						tmp_p = arg2.ptr;
						}
					else	{
						tmp[0] = v_getint(&arg2);
						tmp[1] = '\0';
						tmp_p = tmp;
						len = 1;
						}

					if	( len == 0 || count == 0 )	{
						rt_raise("STRING$(): argument error");
						r->type = V_INT;	// dont try to free
						}
					else	{
						r->ptr = tmp_alloc(count*len+1);
					   *((char *)(r->ptr)) = '\0';
						for ( i = 0; i < count; i ++ )	
							strcat(r->ptr, tmp_p);
						r->size = strlen(r->ptr)+1;
						}
					}
				}
			}
		break;

	case kwLEFT:
		//
		// str <- LEFT$ ( str, int )
		//
		par_getstr(&arg1);
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error )	{
				count = par_getint();
				if	( !prog_error )	{

					len = strlen(arg1.ptr);
					if	( count > len )
						count = len;
					r->ptr = tmp_alloc(count+1);
					memcpy(r->ptr, arg1.ptr, count);
					r->ptr[count] = '\0';
					r->size = strlen(r->ptr)+1;
					}
				}
			}
		break;

	case kwRIGHT:
		//
		//	str <- RIGHT$ ( str, int )
		//
		par_getstr(&arg1);
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error )	{
				count = par_getint();
				if	( !prog_error )	{

					len = strlen(arg1.ptr);
					if	( count > len )
						count = len;
					r->ptr = tmp_alloc(count+1);
					memcpy(r->ptr, arg1.ptr+(len-count), count+1);
					r->size = strlen(r->ptr)+1;

					}
				}
			}
		break;

	case kwMID:
		//
		//	str <- MID$ ( str, start [, len] )
		//
		par_getstr(&arg1);
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error )	{
				start = par_getint();		// start
				if	( !prog_error )	{
					// len
					if	( code_peek() == kwTYPE_SEP )	{
						par_getcomma();
						if ( !prog_error )
							len = par_getint();		// len
						}
					else
						len = -1;

					if	( !prog_error )	{

						lsrc = strlen(arg1.ptr);
						if	( start <= 0 || start > strlen(arg1.ptr) )
							rt_raise("MID$(): 'START' OUT OF RANGE");
						else	{
							start --;

							if	( len == -1 || len + start >= lsrc )
								len = lsrc - start;

							r->ptr = tmp_alloc(len+1);
							memcpy(r->ptr, arg1.ptr+start, len);
							r->ptr[len] = '\0';
							r->size = len+1;
							}
						} 
					} //
				} 
			}

		break;
		}

	v_free(&arg1);
	v_free(&arg2);
	v_free(&arg3);
}

//
//	int <- FUNC (...)
//
void	cmd_intN(byte funcCode, var_t *r)
{
	var_t	arg1, arg2;
	int		l;
	char	*p;
	var_t	*var_p;

	r->type = V_INT;

	if	( prog_error )	return;
	switch ( funcCode )	{
	case kwINSTR:
		//
		//	int <- INSTR ( [start,] str1, str2 )
		//
		eval(&arg1);		if	( prog_error )	return;
		if	( arg1.type != V_STR )	{
			v_getint(&arg1);	
			par_getcomma();		if ( prog_error )	return;
			eval(&arg1);
			if	( arg1.type != V_STR )		{
				err_typemismatch();
				return;
				}
			}
		par_getcomma();		if ( prog_error )	return;
		eval(&arg2);		if	( prog_error )	return;
		if	( arg2.type != V_STR )	{
			err_typemismatch();
			return;
			}

		///
		l = strlen(arg2.ptr);
		p = arg1.ptr;
		r->i = 0;
		while ( *p )	{
			if	( StrNCaselessCompare(p, arg2.ptr, l) == 0 )	{
				r->i = (p - (char*) arg1.ptr) + 1;
				break;
				}
			p ++;
			}

		tmp_free(arg1.ptr);
		tmp_free(arg2.ptr);
		break;
	case kwLBOUND:
		//
		//	int <- LBOUND(array [, dim])
		//
		if	( code_peek() == kwTYPE_VAR )	{
			code_skipnext();
			var_p = tvar[code_getnext16()];
			if	( var_p->type == V_ARRAY )	{

				l = 1;
				if	( code_peek() == kwTYPE_SEP )	{
					par_getcomma();
					if	( !prog_error )	{
						eval(&arg1);
						if	( !prog_error )	
							l = v_getint(&arg1);
						v_free(&arg1);
						}
					}

				if	( !prog_error )	{
					l --;
					if	( l >= 0 && l < var_p->maxdim )
						r->i = var_p->lbound[l];
					else
						rt_raise("LBOUND: Array of %d dimensions (%d)", var_p->maxdim, l);
					}
				}
			else
				rt_raise("LBOUND: Variable is not an array");
			}
		else
			err_typemismatch();
		break;

	case kwUBOUND:
		//
		//	int <- UBOUND(array [, dim])
		//
		if	( code_peek() == kwTYPE_VAR )	{
			code_skipnext();
			var_p = tvar[code_getnext16()];
			if	( var_p->type == V_ARRAY )	{

				l = 1;
				if	( code_peek() == kwTYPE_SEP )	{
					par_getcomma();
					if	( !prog_error )	{
						eval(&arg1);
						if	( !prog_error )	
							l = v_getint(&arg1);
						v_free(&arg1);
						}
					}

				if	( !prog_error )	{
					l --;
					if	( l >= 0 && l < var_p->maxdim )
						r->i = var_p->ubound[l];
					else	 
						rt_raise("UBOUND: Array of %d dimensions", var_p->maxdim);
					}
				}
			else
				rt_raise("UBOUND: Variable is not an array");
			}
		else
			err_typemismatch();
		break;
		}
}

//
//	fp <- FUNC (...)
//
void	cmd_numN(byte funcCode, var_t *r)
{
	double	x, y, m;
	int		pw;

	r->type = V_NUM;

	if	( prog_error )	return;
	switch ( funcCode )	{
	case kwATAN2:
		// fp <- ATAN2(x,y)
		x = par_getnum();
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error ) {
				y = par_getnum();
				r->n = atan2(x,y);
				}
			}
		break;

	case kwPOW:
		// fp <- POW(x,y)
		x = par_getnum();
		if	( !prog_error )	{
			par_getcomma();
			if	( !prog_error ) {
				y = par_getnum();
				r->n = pow(x,y);
				}
			}
		break;

	case kwROUND:
		// fp <- ROUND(x [,decs])
		x = par_getnum();
		if	( !prog_error )	{
			if	( code_peek() == kwTYPE_SEP )	{
				par_getcomma();
				if	( !prog_error )
					pw = par_getint();
				}
			else 
				pw = 0;

			if	( !prog_error )	{
				// round
				m = pow(10.0, pw);
				m = floor(m);
				r->n = floor((x * m) + .5) / m;
				}
			}
		break;
		}
}

//
//	any <- FUNC (...)
//
void	cmd_genfunc(byte funcCode, var_t *r)
{
	byte	code, ready, first;
	int		count, handle, i, len, ch;
	var_t	*basevar_p, *elem_p;
	var_t	arg;
	char	tmp[3];

	if	( prog_error )	return;

	switch ( funcCode )	{
	// STR <- INPUT$(len [, file])
	case	kwINPUTSEP:
		v_init(r);
		count = par_getint();
		if	( prog_error )	return;

		if	( code_peek() == kwTYPE_SEP )	{
			par_getcomma();
			if	( prog_error )	return;

			handle = par_getint();
			if	( prog_error )	return;
			}
		else
			handle = -1;

		if	( handle == -1 )	{
			// keyboard
			r->type = V_STR;
			r->ptr = tmp_alloc((count<<1)+1);
			r->ptr[0] = '\0';
			len = 0;
			for ( i = 0; i < count; i ++ )	{
				if	( dev_kbhit() )	{
					ch = dev_getch();	// MultiByte - dev_getchr() must return the extended code (2 bytes char)
					if	( (ch & 0xFF00) == 0xFF00 )	{	// extra code - hardware keys
						tmp[0] = '\033';
						tmp[1] = ch & 0xFF;
						tmp[2] = '\0';
						len += 2;
						}
					else if ( ch & 0xFF00 )	{		// multibyte languages
						tmp[0] = ch >> 8;
						tmp[1] = ch & 0xFF;
						tmp[2] = '\0';
						len += 2;
						}
					else	{						// simple 8-bit character
						tmp[0] = ch;
						tmp[1] = '\0';
						len ++;
						}
					}

				strcat(r->ptr, tmp);
				}

			r->size = len+1;
			r->ptr[len] = '\0';
			}
		else	{
			// file
			r->type = V_STR;
			r->ptr = tmp_alloc(count+1);
			r->size = count+1;
			dev_fread(handle, r->ptr, count);
			r->ptr[count] = '\0';
			}

		break;
	// ? <- MAX(...)
	case	kwMAX:
	case	kwMIN:
		v_init(r);
		ready = 0;
		first = 1;
		do	{
			code = code_peek();
			switch ( code )	{
			case	kwTYPE_SEP:	// separator 
				code_skipnext16();
				break;
			case	kwTYPE_LEVEL_END:	// ) -- end of parameters
				ready = 1;
				break;
			case	kwTYPE_VAR:		// variable
				if	( code_isnullarray() )	{	// this parameter is an array i.e. MAX(v())
					code_skipnext();
					basevar_p = tvar[code_getnext16()];	// array var_t pointer
					count = basevar_p->size;				// the number of the elements
					for ( i = 0; i < count; i ++ )	{	
						elem_p = v_getelemptr(basevar_p, i);

						if	( !prog_error )	{
							if	( first )	{	// the first element
								v_set(r, elem_p);
								first = 0;
								}
							else	{
								if	( funcCode == kwMAX )	{
									if	( v_compare(r, elem_p) < 0 )
										v_set(r, elem_p);
									}
								else if	( funcCode == kwMIN )	{
									if	( v_compare(r, elem_p) > 0 )
										v_set(r, elem_p);
									}
								}
							}
						else
							return;
						}

					break;
					}
			default:
				// default --- expression
				eval(&arg);
				if	( !prog_error )	{
					if	( first )	{		// the first element i.e. MAX(1) = 1
						v_set(r, &arg);
						first = 0;
						}
					else	{
						if	( funcCode == kwMAX )	{
							if	( v_compare(r, &arg) < 0 )
								v_set(r, &arg);
							}
						else if	( funcCode == kwMIN )	{
							if	( v_compare(r, &arg) > 0 )
								v_set(r, &arg);
							}
						}
					}
				else
					return;
				v_free(&arg);
				}

			//
			} while ( !ready );
		break;
		};
}