int get_string_value(char *string, int bit)
{
if(string == NULL)
{
return -1;
}
char *p = string;
if(strlen(p) < bit)
{
printf("error error .............\n");
return -1;
}
p = p + bit - 1;
if(is_valid_number(*p))
{
if(*p <= '9')
{
return (*p - '0');
}
else if(*p <= 'F')
{
return 10 + (*p - 'A');
}
else
{
return 10 + (*p - 'a');
}
}
return -1;
}
int main(int argc, char **argv)
{
char **sudo_tb;
int index;
int index_malloc;
index_malloc = 0;
if (argc == 10 && is_valid_number(argv) == 1)
{
index = 0;
sudo_tb = (char**)malloc(9 * sizeof(char*));
while (index_malloc < 9)
{
sudo_tb[index_malloc] = (char*)malloc(10 * sizeof(char));
index_malloc++;
}
copy_sudo(argv, sudo_tb);
if (is_valid_char(argv) == 1 && sudoku(sudo_tb, 0))
print_sudoku(sudo_tb);
else
write(1, "Erreur\n", 7);
free_grid(sudo_tb);
}
else
write(1, "Errer\n", 7);
return (0);
}
TokenType token_type(const string &str)
{
if (is_valid_operator(str))
return operator_symbol;
if (is_valid_operator_as_function(str))
return op_function;
if (is_valid_identifier(str))
return plain_identifier;
if (is_valid_symbol(str))
return symbol;
if (is_valid_label(str))
return label;
if (is_valid_number(str))
return number;
if (is_valid_type_name(str))
return type_id;
if (is_valid_type_var(str))
return type_var;
if (is_valid_builtin(str))
return builtin;
if (is_valid_string_lit(str))
return string_lit;
return invalid;
}
int main(int argc, string argv[])
{
if (argc < 2)
{
printf("usage: ./sort0 number [number] ...\n");
return 1;
}
int length = argc - 1;
int numbers[length];
for (int i = 0, j = 1; i < length; i++, j++)
{
if (is_valid_number(argv[j]))
{
int number = atoi(argv[j]);
numbers[i] = number;
}
else
{
printf("wrong input: [%d] = %s\n",
j,
argv[j]);
return 2;
}
}
print_array(length, numbers);
bubble_sort(length, numbers);
print_array(length, numbers);
return 0;
}
// Aplly Operation
bool Expression::apply_operation(Term _t1, Term _t2, Term _op, Term &_rst) {
if (is_operator(_op)) {
int result, v1, v2;
if (!is_valid_number(_t1) || !is_valid_number(_t2)) {
set_error(8);
return false;
}
get_int_number(_t1, v1);
get_int_number(_t2, v2);
switch (_op.value[0]) {
case '^':
result = std::pow(v1, v2);
break;
case '*':
result = v1 * v2;
break;
case '/':
if (v2 == 0) {
set_error(7);
return false;
}
result = v1 / v2;
break;
case '%':
if (v2 == 0) {
set_error(7);
return false;
}
result = v1 % v2;
break;
case '+':
result = v1 + v2;
break;
case '-':
result = v1 - v2;
break;
}
_rst.value = std::to_string(result);
if (!is_valid_number(_rst)) {
set_error(8);
return false;
}
return true;
}
return false;
}
cDialog :: cDialog( double nposx, double nposy, string nidentifier, string ntext, DialogType dialogtype, Uint8 nmax_length /* = 20 */, unsigned int nmin_width )
: cSprite( NULL, nposx, nposy )
{
stext = NULL;
if( is_valid_number( ntext.c_str() ) )
{
text_number = string_to_int( ntext );
}
else
{
text_number = 0;
}
identifier.reserve( nidentifier.length() );
identifier = nidentifier;
text = ntext;
type = dialogtype;
boarder_in = 2;
boarder_out = 2;
text_area = 1;
min_width = nmin_width;
if( type != DIALOG_ONLY_NUMBERS )
{
if( nmax_length < ntext.length() )
{
max_length = ntext.length();
}
else
{
max_length = nmax_length;
}
text.reserve( max_length );
}
else
{
if( nmax_length < text_number )
{
max_length = text_number;
}
else
{
max_length = nmax_length;
}
text.reserve( 20 );
}
SetColors( colorDarkBlue, colorBlue, colorWhite, colorBlack );
Update_Boarders();
Update_Text();
}
int main(int argc, const char * argv[]) {
char test[420];
printf("Enter a smallish number: ");
scanf("%[^\n]%*c", test);
if (is_valid_int(test))
modtest(to_int(test));
printf("\n%d\t%d\n",is_valid_int(test),to_int(test));
printf("%d\t%g\n",is_valid_number(test),to_double(test));
return 420;
}
int main(int argc, string argv[])
{
if (argc < 2)
{
printf("usage: ./sort0 number [number] ...\n");
return 1;
}
int length = argc - 1;
int numbers[length];
for (int i = 0, j = 1; i < length; i++, j++)
{
if (is_valid_number(argv[j]))
{
int number = atoi(argv[j]);
numbers[i] = number;
}
else
{
printf("wrong input: [%d] = %s\n", j, argv[j]);
return 2;
}
}
print_array(length, numbers);
bubble_sort(length, numbers);
print_array(length, numbers);
printf("what number are you looking for?\n");
int number = get_int();
printf(search(number, length, numbers)
? "found\n" : "not found\n");
return 0;
}
/* Process array definition */
bool process_array(int sentence_end) {
if (is_valid_variable(words[current_position])) {
// Start definition string
if (!append_to_definition(words[current_position]))
return false;
if (current_position == sentence_end)
return false;
if (++current_position != sentence_end
&& strcmp(words[current_position], w_of) != 0)
return false;
if (++current_position != sentence_end
&& !is_valid_number(words[current_position]))
return false;
if (atoi(words[current_position]) > 1
&& strcmp(words[current_position+1], w_data) != 0)
return false;
if (atoi(words[current_position]) == 1
&& strcmp(words[current_position+1], w_datum) != 0)
return false;
// Insert array number
if (!append_to_definition("["))
return false;
if (!append_to_definition(words[current_position]))
return false;
if (!append_to_definition("]"))
return false;
++current_position;
return true;
}
if (current_position == sentence_end)
return false;
if (current_position != sentence_end
&& strcmp(words[current_position], w_of) != 0)
return false;
if (++current_position != sentence_end
&& !is_valid_number(words[current_position]))
return false;
if (atoi(words[current_position]) > 1
&& strcmp(words[current_position+1], w_data) != 0)
return false;
if (atoi(words[current_position]) == 1
&& strcmp(words[current_position+1], w_datum) != 0)
return false;
// Insert array number
if (!append_to_definition("["))
return false;
if (!append_to_definition(words[current_position]))
return false;
if (!append_to_definition("]"))
return false;
++current_position;
return true;
}
void cDialog :: Get_Focus( void )
{
bool focus = 1;
string text_old = text;
int minwidth_old = min_width;
pDialogManager->Update();
boxRGBA( screen, 0, 0, screen->w, screen->h , 0, 0, 0, 32 );
SDL_EnableUNICODE( 1 );
SDL_EnableKeyRepeat( SDL_DEFAULT_REPEAT_DELAY, 50 );
while( focus )
{
Update();
if( rect.w < min_width )
{
rect.w = min_width;
}
else if( rect.w > min_width )
{
min_width = rect.w;
}
SDL_Flip( screen );
while( SDL_PollEvent( &event ) )
{
keys = SDL_GetKeyState( NULL );
if( KeyPressed( KEY_ESC) && event.key.keysym.sym != SDLK_BACKSPACE )
{
text = text_old;
focus = 0;
}
else if ( KeyPressed( KEY_ENTER ) )
{
focus = 0;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_BACKSPACE )
{
if( text.length() && type != DIALOG_ONLY_NUMBERS )
{
text.erase( text.length() - 1, 1 );
Update_Text();
}
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym != SDLK_ESCAPE )
{
if( type != DIALOG_ONLY_NUMBERS )
{
if( event.key.keysym.unicode && text.length() < max_length )
{
if( type == DIALOG_ONLY_LETTERS )
{
string s;
s.insert( (string::size_type)0, (string::size_type)1, (char)event.key.keysym.unicode );
if( !is_valid_number( s ) )
{
text.insert( text.length(), s );
}
}
else
{
text.insert( text.length(), 1, (char)event.key.keysym.unicode );
}
Update_Text();
}
}
else
{
if( KeyPressed( KEY_UP ) )
{
text_number += 1;
}
else if( KeyPressed( KEY_DOWN ) )
{
text_number -= 1;
}
else if( KeyPressed( KEY_LEFT ) )
{
text_number -= 10;
}
else if( KeyPressed( KEY_RIGHT ) )
{
text_number += 10;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PLUS )
{
text_number += 1;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_MINUS )
{
text_number -= 1;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PAGEUP )
{
text_number += 10;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PAGEDOWN )
{
text_number -= 10;
}
if( text_number > max_length )
{
text_number = max_length;
}
else if( text_number < 0 )
{
text_number = 0;
}
Update_Text();
}
}
}
Framerate.Update();
}
SDL_EnableUNICODE( 0 );
SDL_EnableKeyRepeat( 0, 0 );
if( text.compare( text_old ) != 0 )
{
changed = 1;
}
min_width = minwidth_old;
Update_Text();
Framerate.Reset();
}
local void line_minimize
(
double vect[],
double direction[],
double *pval_min,
double *psave_x0,
double *psave_a,
double (*pfunction)(double vect[])
)
{
double ax,bx,cx,x0,fa,fb,fc,fx0;
double a,b;
double old_x0,old_a;
int code;
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_LINESEARCH)
{
printf("start line minimize.\n");
}
last_line_function_x_valid = FALSE;
wn_copy_vect(buffer_vect,vect,num_vars);
save_vect = vect;
save_direction = direction;
save_pfunction = pfunction;
old_x0 = *psave_x0;
old_a = *psave_a;
bx = 0.0;
fb = *pval_min;
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("First point at %lg, function value = %lg\n", bx, fb);
}
if(old_x0 == 0.0)
{
old_x0 = 1.0;
}
ax = old_x0*wn_random_double_between(0.9,1.1);
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("Second point at %lg (old_x0 = %lg)\n", ax, old_x0);
}
fa = line_function(ax);
if(!(old_a > 0.0))
{
goto simple_parabola_fit;
}
/* the curvature along a search direction is constant for a
quadratic function, therefore, try to use the curvature
from the last search */
fit_parabola_2pa(&code,&x0,&b,old_a,ax,fa,bx,fb);
if(
(code != WN_SUCCESS)
||
(!(wn_abs(x0)<MAX_EXPAND*wn_abs(old_x0)) && (*psave_x0 != 0.0))
||
too_close(x0, ax) || too_close(x0, bx)
||
!is_valid_number(x0) || !is_valid_number(ax) || !is_valid_number(bx)
)
{
goto simple_parabola_fit;
}
cx = x0;
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("Third point at %lg\n", cx);
}
fc = line_function(cx);
wn_fit_parabola_3p(&code,&a,&x0,&b,ax,fa,bx,fb,cx,fc);
if((code != WN_SUCCESS)||(!(a > 0.0))||
(!(wn_abs(x0)<MAX_EXPAND*wn_abs(old_x0))&&(*psave_x0 != 0.0)))
{
goto full_linesearch;
}
if(!(b < fb))
{
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("Doing slow line search (parabola fit returned suspect min value).\n");
}
goto full_linesearch;
}
if((!(fc < fb))||(!(fc < fa)))
{
/* evaluate one more point */
goto evaluate_x0;
}
/* is it economical to evaluate one more point? */
if((fb-b) <= 1.5*(fb-fc))
{
/* do not evaluate one more point */
wn_swap(fb,fc,double);
wn_swap(bx,cx,double);
goto finish;
}
else
{
/* evaluate one more point */
goto evaluate_x0;
}
simple_parabola_fit:
if(fa < fb)
{
cx = 2.0*ax*wn_random_double_between(0.8,1.2);
}
else
{
cx = -1.0*ax*wn_random_double_between(0.8,1.2);
}
fc = line_function(cx);
wn_fit_parabola_3p(&code,&a,&x0,&b,ax,fa,bx,fb,cx,fc);
if((code != WN_SUCCESS)||(!(a > 0.0))||
(!(wn_abs(x0)<MAX_EXPAND*wn_abs(old_x0))&&(*psave_x0 != 0.0)))
{
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("Parabola fit failed. Switching to slow line search mode.\n");
}
goto full_linesearch;
}
evaluate_x0:
fx0 = line_function(x0);
if(!(fx0 <= fb))
{
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_ALL)
{
printf("Doing a slow line search because f(x0) is too large (x0 = %lg).\n", x0);
}
goto full_linesearch;
}
fb = fx0;
bx = x0;
if(!(fa <= fc))
{
wn_swap(fa,fc,double);
wn_swap(ax,cx,double);
}
if(!(fb <= fa))
{
wn_swap(fb,fa,double);
wn_swap(bx,ax,double);
}
goto finish;
full_linesearch: ;
/*
printf("now.\n");
*/
do
{
if(ax == bx)
{
if(wn_random_bit())
{
ax += wn_random_double_between(-1.0,1.0);
fa = line_function(ax);
}
else
{
bx += wn_random_double_between(-1.0,1.0);
fb = line_function(bx);
}
}
if(ax == cx)
{
if(wn_random_bit())
{
ax += wn_random_double_between(-1.0,1.0);
fa = line_function(ax);
}
else
{
cx += wn_random_double_between(-1.0,1.0);
fc = line_function(cx);
}
}
if(bx == cx)
{
if(wn_random_bit())
{
bx += wn_random_double_between(-1.0,1.0);
fb = line_function(bx);
}
else
{
cx += wn_random_double_between(-1.0,1.0);
fc = line_function(cx);
}
}
} while((ax == bx)||(ax == cx)||(bx == cx));
wn_minimize_1d_raw(&code,&fa,&fb,&fc,&ax,&bx,&cx,fb,&line_function,1,20);
/*
printf("l = %lf\n",bx);
*/
finish: ;
/*
if(show_linesearch)
{
printf("ax=%lg,bx=%lg,cx=%lg,old_x0=%lg\n",ax,bx,cx,old_x0);
}
*/
wn_copy_vect(vect,buffer_vect,num_vars);
/* compute *psave_x0 */
if(wn_abs(bx) < MIN_CONTRACT*wn_abs(old_x0))
{
if(bx < 0.0)
{
*psave_x0 = -MIN_CONTRACT*wn_abs(old_x0);
}
else
{
*psave_x0 = MIN_CONTRACT*wn_abs(old_x0);
}
}
else
{
*psave_x0 = bx;
}
/* compute *psave_a */
wn_fit_parabola_3p(&code,&a,&x0,&b,ax,fa,bx,fb,cx,fc);
if((code != WN_SUCCESS)||(!(a > 0.0)))
{
*psave_a = 0.0;
}
else
{
*psave_a = a;
}
if(*pval_min == fb)
{
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_LINESEARCH)
{
printf("finish line minimize.\n");
fflush(stdout);
}
return; /* do not move if no improvement */
}
wn_add_scaled_vect(vect,direction,bx,num_vars);
*pval_min = fb;
if(wn_conj_direction_debug >= WN_CONJ_DIR_DBG_LINESEARCH)
{
printf("finish line minimize.\n");
fflush(stdout);
}
}
int main() {
/*char c;*/
int choice;
int n;
char str[] = "gee ks f or g ee ks ";
char path[128];
char S[128], T[128];
char *pattern = "-20";
char str1[32], str2[32];
char **s;
/*do {*/
printf("MENU OPTIONS\n");
printf("1 -- remove spaces from string\n");
printf("2-- Check if a given sequence of moves for a robot is circular or not\n");
printf("3 -- Regex matching problem\n");
printf("4 -- Palindrome detection with non-alphanumeric characters\n");
printf("5 -- Normalize the path\n");
printf("6 -- replace space by percentage20 in a string\n");
printf("7 -- minimum window substring\n");
printf("8 -- integer to english words\n");
printf("9 -- restore IP addresses\n");
printf("10 -- check if strings are isomorphic\n");
printf("11 -- function to determine if a string is a valid number without using any built-in function\n");
printf("12 -- reverse string\n");
printf("13 -- reverse words in a sentence\n");
printf("14 -- shortest distance between words\n");
printf("15 -- shortest distance between words\n");
printf("\n");
printf("Enter your choice\n");
scanf("%d",&choice);
switch(choice){
case 1:
removeSpaces(str);
printf("%s", str);
break;
case 2:
printf("Enter path\n");
scanf("%s", path);
printf("path is circular: %s", checkCircularpath(path)?"yes":"no");
break;
case 4:
palindrome();
break;
case 5:
printf("Enter path\n");
fgets(path, 128, stdin);
printf("Normalized path: %s\n", normalize(path));
break;
case 6:
memset(path, '\0', 128);
printf("Enter string\n");
scanf("%s", path);
/*gets(path);*/
replace_spaces(path, pattern);
printf("%s\n", path);
break;
case 7:
printf("Enter the string\n");
scanf("%s", S);
printf("Enter the pattern\n");
scanf("%s", T);
min_window_substring(S, T);
break;
case 8:
/*interger_to_english_words();*/
break;
case 9:
restore_ip_address();
break;
case 10:
printf("Enter strings of equal length\n");
printf("Enter string 1\n");
scanf("%s", S);
printf("Enter string 2\n");
scanf("%s", T);
printf("Strings are isomorphic : %s\n", isomorphic_strings(S, T)?"Yes":"No");
break;
case 11:
printf("Enter the string\n");
scanf(" %[^\n]s", S); //reading a space through scanf
/*fgets(stdin, S, sizeof(S));*/
printf("Is number : %s\n", is_valid_number(S)?"yes":"no");
break;
case 12:
printf("Enter the string\n");
scanf(" %[^\n]s", S); //make scanf work with spaces //make scanf work with spaces
reverse_string(S, strlen(S));
print_string(S, strlen(S));
break;
case 13:
printf("Enter the sentence\n");
scanf(" %[^\n]s", S); //make scanf work with spaces //make scanf work with spaces
/*fgets(S, 128, stdin);*/
reverse_words(S);
print_string(S, strlen(S));
break;
case 14:
printf("Enter number of words\n");
scanf("%d", &n);
s = create_2Dchar_array(n, 128);
input_2Dchar_array(s, n, 128);
printf("enter word 1\n");
scanf("%s", str1);
printf("enter word 2\n");
scanf("%s", str2);
printf("Shortest distance between %s and %s : %d\n", str1, str2, shortest_distance(s, n, str1, str2));
break;
default:
printf("Invalid option\n");
break;
}
printf("\n\n");
/*}while((c=getchar())!='q'); */
return 0;
}
// Tokenize
bool Expression::tokenize() {
bool _was_number = false;
bool _was_whitespace = false;
bool _was_opening_parenthesis = false;
bool _was_closing_parenthesis = false;
bool _was_operator = false;
int _parenthesis_diff = 0;
int _fst_parenthesis = -1;
Term t1, t2;
for (auto i(0u); i < m_expr.size(); i++) {
t2.set(m_expr[i], i);
bool _is_number = is_number(t2);
bool _is_operator = is_operator(t2);
bool _is_opening_parenthesis = is_opening_parenthesis(t2);
bool _is_closing_parenthesis = is_closing_parenthesis(t2);
bool _is_parenthesis = (_is_opening_parenthesis || _is_closing_parenthesis);
bool _is_last_operand = (i == m_expr.size() - 1);
bool _is_whitespace = (t2.value == " ");
bool _was_parenthesis = (_was_opening_parenthesis || _was_closing_parenthesis);
// Verify if the current term is a whitespace
if (_is_whitespace) {
_was_whitespace = true;
if (_is_last_operand) {
if (_was_number) {
m_terms->enqueue(t1);
t1.value = "";
} else if (!_was_closing_parenthesis) {
set_error(1, t2.col + 1);
return false;
}
}
continue;
// Verify if the current term is a number
} else if (_is_number) {
if ((_was_number && _was_whitespace) || _was_closing_parenthesis) {
set_error(3, t2.col);
return false;
}
if (_was_number) {
t1.value += t2.value;
} else {
t1.set(t2.value, i);
}
if (!is_valid_number(t1)) {
set_error(0, t1.col);
return false;
}
if (_is_last_operand)
m_terms->enqueue(t1);
_was_number = true;
_was_opening_parenthesis = false;
_was_closing_parenthesis = false;
_was_operator = false;
// Verify if the current term is a operator or parenthesis
} else if (_is_operator || _is_parenthesis) {
if (_was_number) {
m_terms->enqueue(t1);
t1.value = "";
}
_fst_parenthesis = (_parenthesis_diff == 0) ? -1 : _fst_parenthesis;
if (_is_parenthesis) {
if (_parenthesis_diff == 0)
_fst_parenthesis = t2.col;
_parenthesis_diff += _is_opening_parenthesis ? 1 : -1;
}
if (_parenthesis_diff < 0) {
set_error(4, t2.col);
return false;
}
if (!_was_number) {
if (t2.value == "-" && !_was_closing_parenthesis) {
t2.is_unary = true;
} else if (!_is_parenthesis && !_was_parenthesis) {
set_error(5, t2.col);
return false;
} else if (_was_operator && _is_closing_parenthesis) {
set_error(1, t2.col);
return false;
}
}
if (_is_last_operand && !_is_parenthesis) {
set_error(1, t2.col + 1);
return false;
}
if (_is_opening_parenthesis && _was_closing_parenthesis) {
set_error(3, t2.col);
return false;
}
if (_is_closing_parenthesis && _was_opening_parenthesis) {
set_error(1, t2.col);
return false;
}
m_terms->enqueue(t2);
_was_number = false;
if (_is_operator) {
_was_operator = true;
_was_opening_parenthesis = false;
_was_closing_parenthesis = false;
} else {
_was_operator = false;
if (_is_opening_parenthesis) {
_was_opening_parenthesis = true;
_was_closing_parenthesis = false;
} else {
_was_opening_parenthesis = false;
_was_closing_parenthesis = true;
}
}
// Invalid Operand
} else {
set_error(_was_operator ? 1 : 2, t2.col);
return false;
}
_was_whitespace = false;
}
if (_parenthesis_diff != 0) {
set_error(6, _fst_parenthesis);
return false;
}
return true;
}
static void
load_profile(struct profile *p)
{
FILE *f; /* file handler */
char line[ED_MAX_LINE_LEN];
int lineno = 0;
int do_points = 0;
int delay_first = -1;
int i;
struct point points[1000]; /* MAX_POINTS_NO */
int points_no = 0;
char *filename = p->filename;
f = fopen(filename, "r");
if (f == NULL) {
err(EX_UNAVAILABLE, "fopen: %s", filename);
}
while (fgets(line, ED_MAX_LINE_LEN, f)) { /* read commands */
char *s, *cur = line, *name = NULL, *arg = NULL;
++lineno;
/* parse the line */
while (cur) {
s = strsep(&cur, ED_SEPARATORS);
if (s == NULL || *s == '#')
break;
if (*s == '\0')
continue;
if (arg)
errx(ED_EFMT("too many arguments"));
if (name == NULL)
name = s;
else
arg = s;
}
if (name == NULL)
continue;
if (!strcasecmp(name, ED_TOK_DELAY)) {
if (do_points)
errx(ED_EFMT("duplicated token: %s"), name);
delay_first = 1;
do_points = 1;
continue;
} else if (!strcasecmp(name, ED_TOK_PROB)) {
if (do_points)
errx(ED_EFMT("duplicated token: %s"), name);
delay_first = 0;
do_points = 1;
continue;
}
if (!strcasecmp(name, ED_TOK_PROFILE_NO)) {
int p_no = atof(arg);
if (p_no <= 0) {
p_no = 100;
printf("invalid interpolation samples, using %d\n",
p_no);
}
if (p_no > ED_MAX_SAMPLES_NO) {
p_no = ED_MAX_SAMPLES_NO;
printf("invalid interpolation samples, using %d\n",
p_no);
}
p->samples_no = p_no;
continue;
} else if (do_points) {
if (!is_valid_number(name) || !is_valid_number(arg))
errx(ED_EFMT("invalid point found"));
if (delay_first) {
points[points_no].delay = atof(name);
points[points_no].prob = atof(arg);
} else {
points[points_no].delay = atof(arg);
points[points_no].prob = atof(name);
}
if (points[points_no].prob > 1.0)
errx(ED_EFMT("probability greater than 1.0"));
++points_no;
/* XXX no more that 1000 */
continue;
} else {
errx(ED_EFMT("unrecognised command '%s'"), name);
}
}
for(i=0; i < p->samples_no; i++) {
p->samples[i] = 666;
}
/* This code assume the user define a value of X for the sampling value,
* and that:
* - the value stored in the emulator structure is X;
* - the allocated structure for the samples is X+1;
*/
interpolate_samples(points, points_no, p->samples, p->samples_no, filename);
// User defined samples
printf("\nLoaded %d points:\n", points_no);
for(i=0; i < points_no; i++) {
printf("%f %f\n", points[i].prob, points[i].delay);
}
printf("\n");
printf("The sample value is %d \n", p->samples_no);
}
/*
* void execute_commands()
*
* Processes commands until the QUIT command is entered
*
*/
void execute_commands() {
char buffer[MAX_INPUT_STRING];
int num_chars = 0;
while ( TRUE ) {
printf( PROMPT );
scanf("%s", buffer);
num_chars = strlen(buffer);
if ( is_valid_number( buffer ) ) {
push( atoi(buffer) );
continue;
}
if ( num_chars > 1 ) {
printf( BAD_INPUT_MSG );
continue;
}
if ( tolower( buffer[0] ) == QUIT ) return;
/* Remove the TODO_MSG as you implement and test commands */
switch( tolower( buffer[0] ) ){
case ADD:
add_command();
break;
case SUB:
sub_command();
break;
case MULT:
mult_command();
break;
case DIV:
div_command();
break;
case MOD:
mod_command();
break;
case AND:
and_command();
break;
case OR:
or_command();
break;
case XOR:
xor_command();
break;
case NOT:
not_command();
break;
case FACTORIAL:
factorial_command();
break;
case TOGGLE_HEX:
toggle_hex();
break;
case TOGGLE_BUG:
toggle_bug();
break;
case PRINT_STACK:
print_stack();
break;
case PRINT_TOP:
print_top();
break;
case CLEAR:
clear_command();
break;
case EXCHANGE:
exchange_command();
break;
case POP:
pop();
break;
case HELP:
help_command();
break;
default:
printf( BAD_INPUT_MSG );
}
}
}
