static modification
test_modification (int i) {
switch (i) {
case 0: return mod_assign (path (), "Hi");
case 1: return mod_insert (path (), 0, tree (TUPLE, "a", "b"));
case 2: return mod_remove (path (), 0, 2);
case 3: return mod_split (path (), 0, 1);
case 4: return mod_join (path (), 0);
case 5: return mod_assign_node (path (), TUPLE);
case 6: return mod_insert_node (path (), 1, tree (TUPLE, "a", "b"));
case 7: return mod_remove_node (path (), 0);
case 8: return mod_insert (path (), 1, tree (TUPLE, "a", "b"));
case 9: return mod_insert (path (), 2, tree (TUPLE, "a", "b"));
case 10: return mod_remove (path (), 1, 2);
case 11: return mod_remove (path (), 2, 2);
case 12: return mod_split (path (), 1, 2);
case 13: return mod_split (path (), 2, 1);
case 14: return mod_join (path (), 1);
case 15: return mod_join (path (), 2);
case 16: return mod_remove_node (path (), 1);
case 17: return mod_remove_node (path (), 2);
case 18: case 19: case 20: case 21: case 22: case 23: case 24: case 25:
return path (0) * test_modification (i-18);
case 26: case 27: case 28: case 29: case 30: case 31: case 32: case 33:
return path (1) * test_modification (i-26);
case 34: case 35: case 36: case 37: case 38: case 39: case 40: case 41:
return path (2) * test_modification (i-34);
default:
FAILED ("not implemented");
return mod_assign (path (), "");
}
}
bool
join (modification& m1, modification m2, tree t) {
if (m1->k == MOD_INSERT &&
m2->k == MOD_INSERT &&
is_atomic (m1->t) &&
root (m1) == root (m2) &&
(index (m2) == index (m1) ||
index (m2) == index (m1) + N (m1->t->label)))
{
string s= m1->t->label * m2->t->label;
if (index (m2) == index (m1))
s= m2->t->label * m1->t->label;
m1= mod_insert (root (m1), index (m1), tree (s));
return true;
}
if (m1->k == MOD_REMOVE &&
m2->k == MOD_REMOVE &&
is_atomic (subtree (t, root (m1))) &&
root (m1) == root (m2) &&
(index (m1) == index (m2) ||
index (m1) == index (m2) + argument (m2)))
{
m1= mod_remove (root (m2), index (m2),
argument (m1) + argument (m2));
return true;
}
return false;
}
int modprobe_main(int argc, char** argv)
{
int rc = EXIT_SUCCESS;
char *unused;
bb_opt_complementally = "?V-:q-v:v-q";
main_opts = bb_getopt_ulflags(argc, argv, "acdklnqrst:vVC:",
&unused, &unused);
if((main_opts & (DUMP_CONF_EXIT | LIST_ALL)))
return EXIT_SUCCESS;
if((main_opts & (RESTRICT_DIR | CONFIG_FILE)))
bb_error_msg_and_die("-t and -C not supported");
depend = build_dep ( );
if ( !depend )
bb_error_msg_and_die ( "could not parse modules.dep" );
if (remove_opt) {
do {
if (mod_remove ( optind < argc ?
argv [optind] : NULL )) {
bb_error_msg ("failed to remove module %s",
argv [optind] );
rc = EXIT_FAILURE;
}
} while ( ++optind < argc );
} else {
if (optind >= argc)
bb_error_msg_and_die ( "No module or pattern provided" );
if ( mod_insert ( argv [optind], argc - optind - 1, argv + optind + 1 ))
bb_error_msg_and_die ( "failed to load module %s", argv [optind] );
}
/* Here would be a good place to free up memory allocated during the dependencies build. */
return rc;
}
int modprobe_main(int argc, char **argv)
{
int rc = EXIT_SUCCESS;
char *unused;
opt_complementary = "q-v:v-q";
getopt32(argv, MAIN_OPT_STR, &unused, &unused);
if (option_mask32 & (DUMP_CONF_EXIT | LIST_ALL))
return EXIT_SUCCESS;
if (option_mask32 & (RESTRICT_DIR | CONFIG_FILE))
bb_error_msg_and_die("-t and -C not supported");
depend = build_dep();
if (!depend)
bb_error_msg_and_die("cannot parse "CONFIG_DEFAULT_DEPMOD_FILE);
if (remove_opt) {
do {
/* argv[optind] can be NULL here */
if (mod_remove(argv[optind])) {
bb_error_msg("failed to %s module %s", "remove",
argv[optind]);
rc = EXIT_FAILURE;
}
} while (++optind < argc);
} else {
if (optind >= argc)
bb_error_msg_and_die("no module or pattern provided");
if (mod_insert(argv[optind], argc - optind - 1, argv + optind + 1))
bb_error_msg_and_die("failed to %s module %s", "load", argv[optind]);
}
/* Here would be a good place to free up memory allocated during the dependencies build. */
return rc;
}
modification
invert (modification m, tree t) {
ASSERT (is_applicable (t, m), "modification not applicable");
path rp= root (m);
switch (m->k) {
case MOD_ASSIGN:
return mod_assign (rp, copy (subtree (t, rp)));
case MOD_INSERT:
return mod_remove (rp, index (m), insert_length (m->t));
case MOD_REMOVE:
{
int i= index (m);
int n= argument (m);
return mod_insert (rp, i, copy (insert_range (subtree (t, rp), i, n)));
}
case MOD_SPLIT:
return mod_join (rp, index (m));
case MOD_JOIN:
{
int i= index (m);
return mod_split (rp, i, insert_length (subtree (t, rp * i)));
}
case MOD_ASSIGN_NODE:
return mod_assign_node (rp, L (subtree (t, rp)));
case MOD_INSERT_NODE:
return mod_remove_node (rp, argument (m));
case MOD_REMOVE_NODE:
{
tree u= subtree (t, rp);
int i= index (m);
return mod_insert_node (rp, i, copy (u (0, i) * u (i+1, N(u))));
}
case MOD_SET_CURSOR:
return m;
default:
FAILED ("unexpected situation");
}
}
extern int modprobe_main(int argc, char** argv)
{
int opt;
int remove_opt = 0;
autoclean = show_only = quiet = do_syslog = verbose = 0;
while ((opt = getopt(argc, argv, "acdklnqrst:vVC:")) != -1) {
switch(opt) {
case 'c': // no config used
case 'l': // no pattern matching
return EXIT_SUCCESS;
break;
case 'C': // no config used
case 't': // no pattern matching
error_msg_and_die("-t and -C not supported");
case 'a': // ignore
case 'd': // ignore
break;
case 'k':
autoclean++;
break;
case 'n':
show_only++;
break;
case 'q':
quiet++;
break;
case 'r':
remove_opt++;
break;
case 's':
do_syslog++;
break;
case 'v':
verbose++;
break;
case 'V':
default:
show_usage();
break;
}
}
depend = build_dep ( );
if ( !depend )
error_msg_and_die ( "could not parse modules.dep\n" );
if (remove_opt) {
do {
mod_remove ( optind < argc ? xstrdup ( argv [optind] ) : 0 );
} while ( ++optind < argc );
return EXIT_SUCCESS;
}
if (optind >= argc)
error_msg_and_die ( "No module or pattern provided\n" );
return mod_insert ( xstrdup ( argv [optind] ), argc - optind - 1, argv + optind + 1 ) ? \
EXIT_FAILURE : EXIT_SUCCESS;
}
/*
****************************************************************
* Cria o arquivo de sinopse *
****************************************************************
*/
int
do_replace (const char *argv[])
{
MOD *mp, *lp, *ap;
const char *mod_nm, **cpp;
char *mod_path, *nm_point;
int len, max_len, r, modif = 0, sort = 0;
STAT s;
HEADER h;
/*
* Pequena consistência
*/
if (argv[0] == NOSTR)
error ("$A substituição deve ter nomes de <módulo>s");
/*
* Lê a sinopse e insere todos os símbolos na tabela HASH
*/
read_sinop_file (1);
if ((hash_tb = calloc (HASHSZ, sizeof (SYMTB *))) == NULL)
error (NOSTR);
hash_all_sym ();
/*
* Prepara o prefixo dos nomes dos módulos
*/
for (cpp = argv, max_len = 0; *cpp != NOSTR; cpp++)
{
if (max_len < (len = strlen (*cpp)))
max_len = len;
}
mod_path = alloca (lib_dir_nm_len + 1 + max_len);
strcpy (mod_path, lib_dir_nm);
strcat (mod_path, "/"); nm_point = strend (mod_path);
/*
* Processa cada um dos argumentos (módulos)
*/
while ((mod_nm = *argv++) != NOSTR)
{
strcpy (nm_point, mod_nm);
if (mod_copy (last_nm (mod_nm), /* => */ mod_path, &s, &h) < 0)
continue;
/*
* Verifica se o módulo já está na biblioteca
*/
if ((mp = mod_search (mod_nm)) == NOMOD)
{
/* O módulo ainda NÃO pertence à biblioteca */
if ((mp = malloc (sizeof (MOD))) == NOMOD)
error (NOSTR);
mp->m_mod_nm = mod_nm;
mp->m_ino = s.st_ino;
/*** mp->m_sym = ...; ***/
/*** mp->m_n_sym = ...; ***/
/*** mp->m_next = ...; ***/
/* Insere já no local correto da lista */
for (ap = NOMOD, lp = mod_first; lp != NOMOD; ap = lp, lp = lp->m_next)
{
if (strcmp (lp->m_mod_nm, mp->m_mod_nm) > 0)
break;
}
if (ap == NOMOD)
mod_first = mp;
else
ap->m_next = mp;
mp->m_next = lp;
if (mod_insert (mod_nm, mp, &s, &h) < 0)
continue;
modif++; sort++;
}
else
{
/* O módulo já pertence à biblioteca */
if ((r = mod_replace (mp, &s, &h, 'r')) > 0)
modif += r;
}
} /* end for (nomes de módulos) */
free (hash_tb);
if (sort)
return (-modif); /* < 0 => Ordena */
else
return (modif);
} /* end do_replace */
