int check_av(int ac, char **av, t_d *d)
{
int ac_var;
int dash;
if (ac == 1)
return (0);
if ((d->tab_arg = malloc(ac * sizeof(t_argv))) == NULL)
ft_exit_prog("Fail to malloc d->tab_arg\n", FG_RED, 0);
ac_var = 1;
dash = 0;
while (ac_var < ac)
{
check_arg(av, d, &ac_var, 0);
if (av[ac_var][0] == '\0')
ft_exit_prog("ft_ls: fts_open: No such file or directory\n"
, CS_RESET, 1);
ac_var++;
}
if (d->nb_option + 1 != ac)
{
detect_arg_true(d, 0);
d->arg = 1;
if (d->arg_true == 0)
exit(0);
}
return (0);
}
int write_instructions(int fd, int fdwrite)
{
char *tmp;
int size;
int i;
char *ins;
char *param;
t_asm *my_asm;
i = 2;
my_asm = NULL;
while ((tmp = get_next_line(fd)))
{
i++;
if (tmp != NULL && tmp[0] != '.' && all_space(tmp) != 0)
{
tmp = remove_space(tmp);
ins = parse_action(tmp, 0);
param = parse_action(tmp, 1);
ins = remove_all_space(ins);
param = remove_all_space(param);
if (check_arg(ins) != 1 ||
check_param(ins, param) != 1)
return (error_line(i));
my_asm = add_action(my_asm, ins, param);
}
}
my_asm = my_asm->next;
if ((size = instructions_file(fdwrite, my_asm)) == -1
|| write_size(fdwrite, size) == -1)
return (-1);
return (0);
}
configuration::configuration(int argc,char *argv[]) {
int i,i_arg,k;
char *arg,*val;
char file[256],line[256];
cmdline_parser cmd;
file_parser fp;
verbose=1;
strcpy(plot_device,"/NULL");
plot_interval=10;
strcpy(output_file,"star.out");
*input_file=0;
*param_file=0;
output_mode='b';
minit=1;
maxit=200;
tol=1e-8;
newton_dmax=0.5;
sprintf(file,"%s/config/star.cfg",ESTER_ROOT);
if(!fp.open(file))
printf("Can't open configuration file %s\n",file);
else {
while(k=fp.get(arg,val)) {
if(i=check_arg(arg,val)) {
printf("Sintax error in configuration file %s, line %d\n",file,k);
if(i==2) missing_argument(arg);
if(i==1) {
printf("Unknown parameter %s\n",arg);
exit(1);
}
}
}
fp.close();
}
cmd.open(argc,argv);
while(int err_code=cmd.get(arg,val)) {
if(err_code==-1) exit(1);
err_code=check_arg(arg,val);
if(err_code==2) missing_argument(arg);
if(err_code==0) cmd.ack(arg,val);
}
cmd.close();
}
LFD(Lrandom_state_p)(void)
{
check_arg(1);
if (type_of(vs_pop) == t_random)
vs_push(Ct);
else
vs_push(Cnil);
}
void quick_checker::collector::collect_core(app * n, func_decl * p, unsigned i) {
func_decl * f = n->get_decl();
unsigned num_args = n->get_num_args();
for (unsigned j = 0; j < num_args; j++) {
expr * arg = n->get_arg(j);
if (is_var(arg)) {
unsigned idx = to_var(arg)->get_idx();
if (idx >= m_num_vars)
return;
if (m_already_found[idx] && m_conservative) {
enode_set & s = m_candidates[idx];
enode_set & ns = m_tmp_candidates[idx];
if (s.empty())
continue;
ns.reset();
for (enode * curr : m_context.enodes_of(f)) {
if (m_context.is_relevant(curr) && curr->is_cgr() && check_arg(curr, p, i) && j < curr->get_num_args()) {
enode * arg = curr->get_arg(j)->get_root();
// intersection
if (s.contains(arg))
ns.insert(arg);
}
}
SASSERT(m_conservative);
s.swap(ns);
}
else {
m_already_found[idx] = true;
enode_set & s = m_candidates[idx];
for (enode * curr : m_context.enodes_of(f)) {
if (m_context.is_relevant(curr) && curr->is_cgr() && check_arg(curr, p, i) && j < curr->get_num_args()) {
enode * arg = curr->get_arg(j)->get_root();
s.insert(arg);
}
}
}
}
else {
if (n->get_family_id() != m_manager.get_basic_family_id())
collect(arg, n->get_decl(), j);
else
collect(arg, nullptr, 0);
}
}
}
static void
FFN(siLAmake_special)(void)
{
check_arg(1);
check_type_symbol(&vs_base[0]);
if ((enum stype)vs_base[0]->s.s_stype == stp_constant)
FEerror("~S is a constant.", 1, vs_base[0]);
vs_base[0]->s.s_stype = (short)stp_special;
}
int main(int ac, char **av)
{
if (ac > 2)
{
if (check_arg(ac, av) == 0)
return (0);
ft_pushswap(ac, av);
}
return (0);
}
void main(int ac, char **av)
{
if (ac == 2)
{
check_arg(av[1]);
borwein(check_n(atof(av[1])));
}
else
exit_write("Usage\t./110borwein [n]\tWhen n is a number superior or equal to 0");
}
int ambient(t_env *e, char *str)
{
char **tmp;
tmp = ft_strsplit(str, BREAK);
if (tmp[1] == NULL || check_arg(tmp[1], 1) == -1)
return (free_ret(-1, tmp));
e->ambient = ft_atod(tmp[1]);
return (free_ret(0, tmp));
}
int main(int ac, char **av)
{
int *numbers;
if (ac < 2)
ps_error();
check_arg(av + 1);
numbers = convertav(av + 1, ac - 1);
init_piles(ac - 1, numbers);
return (0);
}
static void message(u_char *message, void *arg)
{
fail_unless(message != NULL, "parser_message");
check_arg(arg);
fail_unless(strcmp(message, MESSAGE) == 0, "unsuspected message");
__call_count++;
__call_info |= MESSAGE_CALL;
}
int pov(t_env *e, char *str)
{
char **tmp;
char **tmp1;
tmp1 = ft_strsplit(str, BREAK);
if (tmp1[1] == NULL)
return (free_ret(-1, tmp1));
tmp = ft_strsplit(tmp1[1], BREAK2);
free_ret(0, tmp1);
if (check_arg(tmp[0], 0) == -1)
return (free_ret(-1, tmp));
if (check_arg(tmp[1], 0) == -1)
return (free_ret(-1, tmp));
if (check_arg(tmp[2], 0) == -1)
return (free_ret(-1, tmp));
e->cam.pos = init_vec(ft_atod(tmp[0]), ft_atod(tmp[1]),
ft_atod(tmp[2]));
return (free_ret(0, tmp));
}
int nb_light(t_env *e, char *str)
{
char **tmp;
tmp = ft_strsplit(str, BREAK);
if (tmp[1] == NULL || check_arg(tmp[1], 0) == -1)
return (free_ret(-1, tmp));
e->nb_light_malloc = ft_atoi(tmp[1]);
e->lights = (t_light *)malloc(sizeof(t_light) * e->nb_light_malloc);
return (free_ret(0, tmp));
}
/* This also analyzes commands to determine the maximum
variable,flag,counter,question,and userstr used. */
void truncate_cmd(void)
{
int i, j;
const opdef *opdata;
cntvar=cntflag=cntcnt=cntquest=cntstr=cntsub=0;
for(i=0;i<last_cmd;i++) {
j=0;
while(j<command[i].cmdsize) {
if (command[i].data[j]>=END_ACT) break;
opdata=get_opdef(command[i].data[j++]);
if (opdata==&illegal_def)
agtwarn("Illegal opcode found.",1);
if (j+opdata->argnum>command[i].cmdsize ||
opdata==&illegal_def) {
j=command[i].cmdsize; /* To prevent cmdsize from being changed */
if (!(opdata==&illegal_def))
agtwarn("Command block overrun",0);
break;
}
/* Note: j now points to the token *after* the opcode */
if (opdata->argnum>=1) {
check_arg(opdata->arg1,command[i].data[j++]);
if (opdata->argnum>=2)
check_arg(opdata->arg2,command[i].data[j++]);
}
}
if (j<command[i].cmdsize)
command[i].cmdsize=j+1;
}
if (VAR_NUM>cntvar) VAR_NUM=cntvar;
if (FLAG_NUM>cntflag) FLAG_NUM=cntflag;
if (CNT_NUM>cntcnt) CNT_NUM=cntcnt;
if (MAX_USTR>cntstr) MAX_USTR=cntstr;
if (MAX_SUB>cntsub) MAX_SUB=cntsub;
if (MaxQuestion>cntquest) MaxQuestion=cntquest;
}
LFD(Lmake_random_state)(void)
{
int j;
object x;
j = vs_top - vs_base;
if (j == 0)
vs_push(Cnil);
check_arg(1);
x = make_random_state(vs_head);
vs_top = vs_base;
vs_push(x);
}
unsigned int grub_loader_cmdline_size (int argc, char *argv[])
{
int i;
unsigned int size = 0;
for (i = 0; i < argc; i++)
{
size += check_arg (argv[i], 0);
size++; /* Separator space or NULL. */
}
return size;
}
static void L1()
{register object *base=vs_base;
register object *sup=base+VM1; VC1
vs_check;
check_arg(3);
base[0]=MMcons(base[0],Cnil);
base[1]=MMcons(base[1],base[0]);
base[2]=MMcons(base[2],base[1]);
vs_top=sup;
base[3]=
make_cclosure_new(LC2,Cnil,base[2],Cdata);
vs_top=(vs_base=base+3)+1;
return;
}
LFD(Lrandom)(void)
{
int j;
object x;
j = vs_top - vs_base;
if (j == 1)
vs_push(symbol_value(Vrandom_state));
check_arg(2);
check_type_random_state(&vs_base[1]);
x = rando(vs_base[0], vs_base[1]);
vs_top = vs_base;
vs_push(x);
}
static void L13()
{register object *base=vs_base;
register object *sup=base+VM13; VC13
vs_check;
{object V13;
register object V14;
check_arg(2);
V13=(base[0]);
V14=(base[1]);
vs_top=sup;
goto TTL;
TTL:;
if(((VV[2]->s.s_dbind))!=Cnil){
goto T41;}
if(((VV[3]->s.s_dbind))==Cnil){
goto T41;}
base[2]= (V13);
base[3]= (V14);
vs_top=(vs_base=base+2)+2;
(void) (*Lnk173)();
return;
goto T41;
T41:;
{object V15;
object V16;
object V17;
V15= (*(LnkLI174))((V13),(V14));
base[5]= VV[4];
base[6]= (V15);
vs_top=(vs_base=base+5)+2;
(void) (*Lnk175)();
vs_top=sup;
V16= vs_base[0];
if(((V14))==Cnil){
goto T54;}
V17= VV[5];
goto T52;
goto T54;
T54:;
V17= Cnil;
goto T52;
T52:;
base[5]= VV[6];
base[6]= (V15);
base[7]= listA(4,VV[7],VV[8],(V14),append((V16),(V17)));
vs_top=(vs_base=base+5)+3;
(void) (*Lnk176)();
return;}
}
}
static int
check_argv(const char * arg)
{
if (strcmp(arg, "-b") == 0) {
bytecell = 1;
} else if (strcmp(arg, "-m") == 0) {
check_arg(arg);
opt_optim = disable_init_optim = 1;
} else if (strcmp(arg, "-O") == 0) {
opt_optim = 1;
enable_optim = 1;
} else if (strcmp(arg, "-p") == 0) {
disable_init_optim = 1;
} else if (strcmp(arg, "-#") == 0 && check_arg(arg)) {
enable_debug++;
} else if (strcmp(arg, "-R") == 0) {
enable_rle++;
} else if (strcmp(arg, "-h") == 0) {
return 0;
} else if (strncmp(arg, "-M", 2) == 0 && arg[2] != 0) {
tapelen = strtoul(arg+2, 0, 10);
if (tapelen < 1) tapelen = TAPELEN;
return 1;
} else if (check_arg(arg)) {
;
} else if (strcmp(arg, "-be-pipe") == 0) {
if (be_interface.disable_be_optim) return 0;
backend_only = 1;
enable_rle++;
enable_debug = 1;
}
else return 0;
return 1;
}
static void L8()
{register object *base=vs_base;
register object *sup=base+VM8; VC8
vs_check;
check_arg(0);
vs_top=sup;
goto TTL;
TTL:;
base[0]= VV[1];
base[1]= Ct;
base[2]= Cnil;
vs_top=(vs_base=base+0)+3;
(void) (*Lnk171)();
return;
}
int check_re_exec(char **shArgs)
{
int isValid = 0;
if(shArgs[1] == NULL) {
if(strcmp("!", shArgs[0]) == 0) {
char *cmd = get_last_cmd();
if(cmd != NULL) {
isValid = 1;
re_exec_cmd = strdup(cmd);
}
} else {
int len = strlen(shArgs[0]);
char arg[len];
strncpy(arg, shArgs[0] + 1, len -1);
arg[len - 1] = '\0';
isValid = check_arg(arg);
}
} else if(shArgs[2] == NULL) {
if(strcmp("!", shArgs[0]) == 0) {
isValid = check_arg(shArgs[1]);
}
}
return isValid;
}
model::model(init_arg *args)
{
arma::arma_rng::set_seed_random();
check_arg(*args);
set_arg(args);
training_mean = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
training_cov = make_unique<mat_t>(NUM_TRAINING_DATA, NUM_TRAINING_DATA, arma::fill::zeros);
chol_cov = make_unique<mat_t>(NUM_TRAINING_DATA, NUM_TRAINING_DATA, arma::fill::zeros);
mixture_cov = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
testing_cov = make_unique<vec_t>(1, arma::fill::zeros);
alpha = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
v = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
testing_target = make_unique<vec_t>(NUM_TESTING_DATA, arma::fill::zeros);
testing_var = make_unique<vec_t>(NUM_TESTING_DATA, arma::fill::zeros);
}
void cmd_rm(int ac, char *av[])
{
if(ac < 2)
{
fprintf(stderr, "Not enough arguments.\n");
return;
}
unlink(av[1]);
if(check_arg(av, "-v"))
{
printf("rm %s\n", av[1]);
}
}
int main(int ac, char **arv)
{
int error;
#ifdef DEBUG
/* logfile=/var/log/log.txt */
create_log();
fprintf(log_path, "ac = %d\n", ac);
fflush(log_path);
#endif
/* setup signal handlers */
init_signals();
/* printer DEVICE ID and command line option check */
if((error = get_printer_devid()) < 0 || check_arg(ac,arv) < 0){
/*
Not Canon printer
or
"--gui" option not found
*/
#ifdef DEBUG
write_log("Now normal printing ......\n");
#endif
print_normal();
exit(0);
}
/* create semapho and other setup */
if((error = lm_init(PRNT_PATH))){
exit(0);
}
/* monitor_process/print_process/status_process start */
lm_main_fork();
/* delete semapho */
remove_sem(sem_id);
/* free memory (status monitor argv string) */
free_arg();
#ifdef DEBUG
write_log("LM end \n");
#endif
exit(0);
}
int main(int argc, char * argv[]){
int num_philoshers= 0;
int eat_times = 0;
printf("starting program\n");
//get arguments
if(check_arg(argc, argv, &num_philoshers,&eat_times) != 1){
if(eat_times != 0 && num_philoshers != 0){
//start program
error(creat(num_philoshers,eat_times));
}else{
printf("ERROR: wrong value for arguments!\n");
}
}else{
printf("ERROR: wrong amount of arguments!\n");
}
return 0;
}
int main(int ac, char **av)
{
t_frac frac;
if (ac >= 2)
check_arg(av, &frac.img, &frac);
else
{
cat_readme();
return (0);
}
mlx_mouse_hook(frac.img.win, ft_mouse_hook, &frac);
mlx_hook(frac.img.win, 2, 1, ft_key_press, &frac);
mlx_hook(frac.img.win, MOTIONNOTIFY, POINTERMOTIONMASK, ft_move_mouse,
&frac);
mlx_loop(frac.img.mlx);
}
static void L5()
{register object *base=vs_base;
register object *sup=base+VM5; VC5
vs_check;
{object V5;
check_arg(1);
V5=(base[0]);
vs_top=sup;
goto TTL;
TTL:;
base[1]= VV[0];
base[2]= Cnil;
base[3]= (V5);
vs_top=(vs_base=base+1)+3;
(void) (*Lnk171)();
return;
}
}
static void L4()
{register object *base=vs_base;
register object *sup=base+VM4; VC4
vs_check;
{object V4;
check_arg(1);
V4=(base[0]);
vs_top=sup;
goto TTL;
TTL:;
base[1]= VV[1];
base[2]= small_fixnum(2);
base[3]= (V4);
vs_top=(vs_base=base+1)+3;
(void) (*Lnk170)();
return;
}
}
static void L1()
{register object *base=vs_base;
register object *sup=base+VM1; VC1
vs_check;
{object V1;
check_arg(1);
V1=(base[0]);
vs_top=sup;
goto TTL;
TTL:;
base[1]= VV[0];
base[2]= small_fixnum(1);
base[3]= (V1);
vs_top=(vs_base=base+1)+3;
(void) (*Lnk170)();
return;
}
}
