void Dictionary::reorder_dictionary() {
// Copy all the dictionary entries into a single master list.
DictionaryEntry* master_list = NULL;
for (int i = 0; i < table_size(); ++i) {
DictionaryEntry* p = bucket(i);
while (p != NULL) {
DictionaryEntry* tmp;
tmp = p->next();
p->set_next(master_list);
master_list = p;
p = tmp;
}
set_entry(i, NULL);
}
// Add the dictionary entries back to the list in the correct buckets.
while (master_list != NULL) {
DictionaryEntry* p = master_list;
master_list = master_list->next();
p->set_next(NULL);
Symbol* class_name = InstanceKlass::cast((Klass*)(p->klass()))->name();
// Since the null class loader data isn't copied to the CDS archive,
// compute the hash with NULL for loader data.
unsigned int hash = compute_hash(class_name, NULL);
int index = hash_to_index(hash);
p->set_hash(hash);
p->set_loader_data(NULL); // loader_data isn't copied to CDS
p->set_next(bucket(index));
set_entry(index, p);
}
}
void qr_decomp(double* a, int rows, int cols, int ldim)
{
double rho, s, c, tau, alpha;
int i, k, j;
for (k = 0; k < min_int(rows, cols); k++) {
for (i = k + 1; i < rows; i++) {
if (get_entry(a, ldim, i, k) == 0) {
rho = 1.0;
c = 1.0;
s = 0.0;
} else if (fabs(get_entry(a, ldim, k, k)) >= fabs(get_entry(a, ldim, i, k))) {
tau = get_entry(a, ldim, i, k) / get_entry(a, ldim, k, k);
rho = tau / (sqrt(tau*tau + 1.0));
s = rho;
c = sqrt(1.0 - (s*s));
} else {
tau = get_entry(a, ldim, k, k) / get_entry(a, ldim, i, k);
rho = sqrt(tau*tau + 1.0) / tau;
c = 1.0 / rho;
s = sqrt(1.0 - (c*c));
}
set_entry(a, ldim, k, k, c*get_entry(a, ldim, k, k) + s*get_entry(a, ldim, i, k));
set_entry(a, ldim, i, k, rho);
for (j = k + 1; j < cols; j++) {
alpha = get_entry(a, ldim, k, j);
set_entry(a, ldim, k, j, c*alpha + s * get_entry(a, ldim, i, j));
set_entry(a, ldim, i, j, -s*alpha + c* get_entry(a, ldim, i, j));
}
}
}
}
void DF_T10(double *x, double *dfx, int n)
{
set_entry(dfx, n, 0, 0, exp(1.0 - x[0]));
set_entry(dfx, n, 0, 1, -sin(x[1]));
set_entry(dfx, n, 1, 0, -2*x[0] + x[1] + 1.0);
set_entry(dfx, n, 1, 1, cos(x[1]) + x[0] - 1.0);
}
void lr_pivot(double* a, int n, int ldim, int* p){
int k, i, j, max;
float gamma;
for (k=0; k<n; k++)
{
max = k;
for(i = k+1; i < n; i++)
{
if (fabs(get_entry(a, ldim, i, k)) > fabs(get_entry(a, ldim, max, k)))
{
max = i;
}
}
p[k] = max;
for(j = 0; j < n; j++)
{
gamma = get_entry(a, ldim, k, j);
set_entry(a, ldim, k, j, get_entry(a, ldim, max, j));
set_entry(a, ldim, max, j, gamma);
}
for(i = k+1; i < n; i++)
{
set_entry(a, ldim, i, k, get_entry(a, ldim, i, k)/get_entry(a, ldim, k, k));
for(j = k+1; j < n; j++)
{
set_entry(a, ldim, i, j, get_entry(a, ldim, i, j) - get_entry(a, ldim, i, k) * get_entry(a, ldim, k, j));
}
}
}
}
void
GaussJordan::swap_rows (const int k, const int j)
{
for (int i = k; i < size; i++)
{
const double tmp = get_entry (k, i);
set_entry (k, i, get_entry (j, i));
set_entry (j, i, tmp);
}
const double tmp = value[j];
value[j] = value[k];
value[k] = tmp;
}
static void update_ipv6(void)
{
const struct connman_ipv6 *ipv6, *ipv6_conf;
gboolean method_set = FALSE;
gboolean privacy_set = FALSE;
char value[6];
ipv6 = connman_service_get_ipv6(path);
ipv6_conf = connman_service_get_ipv6_config(path);
if (ipv6 == NULL) {
set_entry(builder, "ipv6_address", "", "");
set_entry(builder, "ipv6_prefix_length", "", "");
set_entry(builder, "ipv6_gateway", "", "");
goto config;
}
memset(value, 0, 6);
snprintf(value, 6, "%u", ipv6->prefix);
set_ipv6_method(ipv6->method);
method_set = TRUE;
set_label(builder, "ipv6_address", ipv6->address, "");
set_label(builder, "ipv6_prefix_length", value, "");
set_label(builder, "ipv6_gateway", ipv6->gateway, "");
set_ipv6_privacy(ipv6->privacy);
privacy_set = TRUE;
config:
if (ipv6_conf == NULL) {
set_entry(builder, "ipv6_conf_address", "", "");
set_entry(builder, "ipv6_conf_prefix_length", "", "");
set_entry(builder, "ipv6_conf_gateway", "", "");
if (ipv6 == NULL)
set_widget_sensitive(builder, "ipv6_settings", FALSE);
return;
}
memset(value, 0, 6);
snprintf(value, 6, "%u", ipv6_conf->prefix);
if (method_set == FALSE)
set_ipv6_method(ipv6_conf->method);
set_entry(builder, "ipv6_conf_address", ipv6_conf->address, "");
set_entry(builder, "ipv6_conf_prefix_length", value, "");
set_entry(builder, "ipv6_conf_gateway", ipv6_conf->gateway, "");
if (privacy_set == FALSE)
set_ipv6_privacy(ipv6_conf->privacy);
}
void build_matrix1d(double* a, int n){
int i, j;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(i==j)
set_entry(a,n,i,j,2.0);
else if(fabs(i-j)==1)
set_entry(a,n,i,j,-1.0);
else
set_entry(a,n,i,j,0.0);
}
}
}
static void update_dns(void)
{
const char *dns, *dns_config, *domains, *domains_config;
dns = connman_service_get_nameservers(path);
dns_config = connman_service_get_nameservers_config(path);
domains = connman_service_get_domains(path);
domains_config = connman_service_get_domains_config(path);
set_entry(builder, "nameservers", dns, "");
set_entry(builder, "nameservers_conf", dns_config, "");
set_entry(builder, "domains", domains, "");
set_entry(builder, "domains_conf", domains_config, "");
}
int main(void){
int i, j, rows, cols;
double *a, *qr;
time_t t;
time(&t);
srand(t);
/* Matrixdimension festlegen (rows = Zeilen, cols = Spalten) */
rows = 3;
cols = 3;
/* Speicher anfordern */
a = (double*) malloc(rows*cols*sizeof(double));
qr = (double*) malloc(rows*cols*sizeof(double));
/* Matrix a erzeugen mit (double) Eintraegen zwischen 0 und 10 */
for(i=0;i<rows;i++)
for(j=0;j<cols;j++){
set_entry(a,rows,i,j,(rand() % 200)/20.0);
set_entry(qr,rows,i,j,get_entry(a,rows,i,j));
}
/* rows und cols ausgeben */
printf("\nrows = %d, cols = %d\n",rows,cols);
/* Minimum von rows und cols ausgeben */
printf("Minimum = %d\n",min_int(rows,cols));
/* Matrix a ausgeben */
printf("\na:\n");
print_matrix(qr,rows,cols);
/* qr-Zerlegung */
qr_decomp(qr,rows,cols,rows);
/* qr-Zerlegung ausgeben */
printf("\nqr:\n");
print_matrix(qr,rows,cols);
/* Speicher freigeben */
free(a);
free(qr);
return 0;
}
/*
* Function: int main(int argc, char args[])
* Description: process main function
* Input: argc: parameter number
* args: parameter value array
* Output: none
* Return: function exit status
* Others: none
*/
int main( )
{
int depth = 0;
Bt * bt = create_bt( );
char a[10][10] = { "2", "8", "1", "3", "9", "4", "7", "5", "6", "0" };
char *b[10];
int i;
Bt_Entry* entry;
for( i = 0; i < 10; i++ )
{
b[i] = a[i];
}
init_bt( bt, b, 10, strcmp );
printf("pre order for this bt\n");
pre_order(bt->root,show_string);
printf("in order for this bt\n");
in_order( bt->root, show_string );
printf("post order for this bt\n");
post_order(bt->root,show_string);
printf("level order for this bt\n");
level_order(bt->root,show_string);
special_level_order(bt->root,2,show_string);
depth = calc_tree_depth( bt->root );
printf( "depth is %d\n", depth );
entry = get_entry( bt->root, "3", strcmp );
if( entry )
{
printf( "entry item is %s\n", entry->item );
} else
{
printf( "entry is NULL\n" );
}
set_entry( bt->root, "3", "33", strcmp );
in_order( bt->root, show_string );
entry = get_parent( bt->root, "33", strcmp );
printf( "parent item is %s\n", entry->item );
entry = get_right( bt->root, "5", strcmp );
if( entry )
{
printf( "right item is %s\n", entry->item );
}
entry = get_left( bt->root, "8", strcmp );
if( entry )
{
printf( "left item is %s\n", entry->item );
}
destroy_bt( bt, NULL );
}
/* Make a new entry named NAME in PARENT. If IS_DIR is true, then the
node revision the new entry points to will be a directory, else it
will be a file. The new node will be allocated in POOL. PARENT
must be mutable, and must not have an entry named NAME.
Use POOL for all allocations, except caching the node_revision in PARENT.
*/
static svn_error_t *
make_entry(dag_node_t **child_p,
dag_node_t *parent,
const char *parent_path,
const char *name,
svn_boolean_t is_dir,
const svn_fs_x__id_part_t *txn_id,
apr_pool_t *pool)
{
const svn_fs_id_t *new_node_id;
node_revision_t new_noderev, *parent_noderev;
/* Make sure that NAME is a single path component. */
if (! svn_path_is_single_path_component(name))
return svn_error_createf
(SVN_ERR_FS_NOT_SINGLE_PATH_COMPONENT, NULL,
_("Attempted to create a node with an illegal name '%s'"), name);
/* Make sure that parent is a directory */
if (parent->kind != svn_node_dir)
return svn_error_create
(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Attempted to create entry in non-directory parent"));
/* Check that the parent is mutable. */
if (! svn_fs_x__dag_check_mutable(parent))
return svn_error_createf
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to clone child of non-mutable node"));
/* Create the new node's NODE-REVISION */
memset(&new_noderev, 0, sizeof(new_noderev));
new_noderev.kind = is_dir ? svn_node_dir : svn_node_file;
new_noderev.created_path = svn_fspath__join(parent_path, name, pool);
SVN_ERR(get_node_revision(&parent_noderev, parent));
new_noderev.copyroot_path = apr_pstrdup(pool,
parent_noderev->copyroot_path);
new_noderev.copyroot_rev = parent_noderev->copyroot_rev;
new_noderev.copyfrom_rev = SVN_INVALID_REVNUM;
new_noderev.copyfrom_path = NULL;
SVN_ERR(svn_fs_x__create_node
(&new_node_id, svn_fs_x__dag_get_fs(parent), &new_noderev,
svn_fs_x__id_copy_id(svn_fs_x__dag_get_id(parent)),
txn_id, pool));
/* Create a new dag_node_t for our new node */
SVN_ERR(svn_fs_x__dag_get_node(child_p, svn_fs_x__dag_get_fs(parent),
new_node_id, pool));
/* We can safely call set_entry because we already know that
PARENT is mutable, and we just created CHILD, so we know it has
no ancestors (therefore, PARENT cannot be an ancestor of CHILD) */
return set_entry(parent, name, svn_fs_x__dag_get_id(*child_p),
new_noderev.kind, txn_id, pool);
}
void initialize()
{
ON = 1;
BLON = 0;
clear_display();
set_entry();
function_set();
display_on();
}
void
GaussJordan::process_column (const int k)
{
for (int i = k + 1; i < size; i++)
{
const double m = -get_entry (i, k) / get_entry (k, k);
for (int j = k; j < size; j++)
set_entry (i, j, get_entry (i, j) + m * get_entry (k, j));
value[i] += m * value[k];
}
}
void m_sub(double* res, double* a, double* b, int ldim, int n, int m)
{
int i, j;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
set_entry(res, ldim, i, j, get_entry(a, ldim, i, j) - get_entry(b, ldim, i, j));
}
}
}
void
PathHandler::_EntryCreated(BMessage* message)
{
const char* name;
node_ref nodeRef;
if (message->FindInt32("device", &nodeRef.device) != B_OK
|| message->FindInt64("directory", &nodeRef.node) != B_OK
|| message->FindString("name", &name) != B_OK) {
TRACE("PathHandler::_EntryCreated() - malformed message!\n");
return;
}
BEntry entry;
if (set_entry(nodeRef, name, entry) != B_OK) {
TRACE("PathHandler::_EntryCreated() - set_entry failed!\n");
return;
}
bool parentContained = false;
bool entryContained = _IsContained(entry);
if (entryContained)
parentContained = _IsContained(nodeRef);
bool notify = entryContained;
if (entry.IsDirectory()) {
// ignore the directory if it's already known
if (entry.GetNodeRef(&nodeRef) == B_OK
&& _HasDirectory(nodeRef)) {
TRACE(" WE ALREADY HAVE DIR %s, %ld:%Ld\n",
name, nodeRef.device, nodeRef.node);
return;
}
// a new directory to watch for us
if ((!entryContained && !_CloserToPath(entry))
|| (parentContained && !_WatchRecursively())
|| _AddDirectory(entry, true) != B_OK
|| _WatchFilesOnly())
notify = parentContained;
// NOTE: entry is now toast after _AddDirectory() was called!
// Does not matter right now, but if it's a problem, use the node_ref
// version...
} else if (entryContained) {
TRACE(" NEW ENTRY PARENT CONTAINED: %d\n", parentContained);
_AddFile(entry);
}
if (notify && entryContained) {
message->AddBool("added", true);
// nodeRef is pointing to the parent directory
entry.GetNodeRef(&nodeRef);
_NotifyTarget(message, nodeRef);
}
}
int main(void){
int n, i;
double *a;
int *p;
/* Matrixdimension festlegen */
n = 3;
/* Speicher anfordern */
a = (double*) malloc(n*n*sizeof(double)); /* Matrix */
p = (int*) malloc(n*sizeof(int)); /* Permutationsvektor */
/* Testmatrix B erzeugen */
set_entry(a, 3, 0, 0, 0);
set_entry(a, 3, 0, 1, 1);
set_entry(a, 3, 0, 2, 3);
set_entry(a, 3, 1, 0, 4);
set_entry(a, 3, 1, 1, 6);
set_entry(a, 3, 1, 2, 0);
set_entry(a, 3, 2, 0, 2);
set_entry(a, 3, 2, 1, 6);
set_entry(a, 3, 2, 2, 3);
/* Matrix ausgeben */
printf("\na:\n");
print_matrix(a,n,n);
/* lr-Zerlegung mit Pivotsuche berechnen */
lr_pivot(a,n,n,p);
/* Matrix ausgeben */
printf("\nlr:\n");
print_matrix(a,n,n);
/* Permutationsvektor ausgeben */
printf("\np:\n");
for(i=0;i<n;i++)
printf(" %d \n",p[i]);
/* Speicher freigeben */
free(a);
free(p);
return 0;
}
PUBLIC static
void
Timer_tick::set_vectors_stop()
{
extern char entry_int_timer_stop[];
// acknowledge timer interrupt once to keep timer interrupt alive because
// we could be called from thread_timer_interrupt_slow() before ack
Timer_tick::_glbl_timer->ack();
// set timer interrupt to dummy doing nothing
Idt::set_entry(Config::scheduler_irq_vector, (Address)entry_int_timer_stop, false);
#if 0
// From ``8259A PROGRAMMABLE INTERRUPT CONTROLLER (8259A 8259A-2)'': If no
// interrupt request is present at step 4 of either sequence (i. e. the
// request was too short in duration) the 8259A will issue an interrupt
// level 7. Both the vectoring bytes and the CAS lines will look like an
// interrupt level 7 was requested.
set_entry(0x27, (Address)entry_int_pic_ignore, false);
set_entry(0x2f, (Address)entry_int_pic_ignore, false);
#endif
}
void qr_decomp(double* a, int m, int n, int ldim){
/* Benoetigte Variablen */
int k, i, j, min;
double rho, tau, c, s, gamma;
/* Minimum aus Zeilen und Spalten */
min = min_int(n,m);
/* qr-Algorithmus */
for(k=0;k<min;k++){
for(i=k+1;i<m;i++){
if(get_entry(a,ldim,i,k)==0.0){
rho = 1.0; c = 1.0; s = 0.0;
}
else if(fabs(get_entry(a,ldim,k,k))>=fabs(get_entry(a,ldim,i,k))){
tau = get_entry(a,ldim,i,k)/get_entry(a,ldim,k,k);
rho = tau/sqrt(tau*tau+1.0);
s = rho;
c = sqrt(1.0-s*s);
}
else{
tau = get_entry(a,ldim,k,k)/get_entry(a,ldim,i,k);
rho = sqrt(tau*tau+1.0)/tau;
c = 1.0/rho;
s = sqrt(1.0-c*c);
}
set_entry(a,ldim,k,k,c*get_entry(a,ldim,k,k)+s*get_entry(a,ldim,i,k));
set_entry(a,ldim,i,k,rho);
for(j=k+1;j<n;j++){
gamma = get_entry(a,ldim,k,j);
set_entry(a,ldim,k,j,c*gamma+s*get_entry(a,ldim,i,j));
set_entry(a,ldim,i,j,-1.0*s*gamma+c*get_entry(a,ldim,i,j));
}
}
}
}
bool MutableMatrix::set_values(M2_arrayint rows,
M2_arrayint cols,
engine_RawRingElementArray values)
{
if (rows->len != cols->len || rows->len != values->len)
return false;
for (size_t i=0; i<rows->len; i++)
{
if (!set_entry(rows->array[i], cols->array[i], values->array[i]->get_value()))
return false;
}
return true;
}
void SMat<CoeffRing>::setFromSubmatrix(const SMat &A, M2_arrayint cols)
{
coeffR = A.coeffR;
initialize(A.numRows(), cols->len, NULL);
for (size_t r = 0; r < nrows_; r++)
for (size_t c = 0; c < cols->len; c++)
{
elem f;
coeffR->init(f);
// coeffR->init(f);
A.get_entry(r, cols->array[c], f);
set_entry(r, c, f);
}
}
gboolean
jam_doc_load_file(JamDoc *doc, const char *filename,
LJEntryFileType type, GError **err) {
LJEntry *entry;
entry = lj_entry_new_from_filename(filename, type, &type, err);
if (!entry)
return FALSE;
entry->itemid = 0;
set_entry(doc, entry);
string_replace(&doc->filename, g_strdup(filename));
doc->filename_not_xml = (type != LJ_ENTRY_FILE_XML);
g_signal_emit_by_name(doc, "entry_changed");
return TRUE;
}
svn_error_t *
svn_fs_x__dag_set_entry(dag_node_t *node,
const char *entry_name,
const svn_fs_id_t *id,
svn_node_kind_t kind,
const svn_fs_x__id_part_t *txn_id,
apr_pool_t *pool)
{
/* Check it's a directory. */
if (node->kind != svn_node_dir)
return svn_error_create
(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Attempted to set entry in non-directory node"));
/* Check it's mutable. */
if (! svn_fs_x__dag_check_mutable(node))
return svn_error_create
(SVN_ERR_FS_NOT_MUTABLE, NULL,
_("Attempted to set entry in immutable node"));
return set_entry(node, entry_name, id, kind, txn_id, pool);
}
void m_mult(double* a, int ma, int na, int transa, double* b, int mb, int nb, int transb, double* c){
int i, j, k, mc, nc, a_cols, b_rows;
double value;
mc = transa*na + (1 - transa)*ma;
nc = transb*mb + (1 - transb)*nb;
a_cols = transa*ma + (1 - transa)*na;
b_rows = transb*nb + (1 - transb)*mb;
if(a_cols!=b_rows){
printf("Fehler in m_mult: %d != %d\n",a_cols,b_rows);
return;
}
for(i=0;i<mc;i++){
for(j=0;j<nc;j++){
value = 0.0;
for(k=0;k<a_cols;k++)
value = value + get_entry(a,ma,(1-transa)*i+transa*k,(1-transa)*k+transa*i)*get_entry(b,mb,(1-transb)*k+transb*j,(1-transb)*j+transb*k);
set_entry(c,mc,i,j,value);
}
}
}
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED
gpointer gdata)
{
InsertNumbersDialog d;
GtkWidget *vbox, *label, *upper, *space, *button;
GtkGrid *grid;
GtkComboBoxText *combo;
const char *case_tip = _("For base 11 and above");
gchar *base_text;
gint result;
d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
#if GTK_CHECK_VERSION(3, 0, 0)
grid = GTK_GRID(gtk_grid_new());
#else
grid = GTK_TABLE(gtk_table_new(3, 6, FALSE));
#endif
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 6);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic(_("_Start:"));
gtk_grid_attach(grid, label, 0, 0, 1, 1);
d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.start, 1, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("S_tep:"));
gtk_grid_attach(grid, label, 3, 0, 1, 1);
d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.step, 4, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("_Base:"));
gtk_grid_attach(grid, label, 0, 1, 1, 1),
combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry());
d.base = gtk_bin_get_child(GTK_BIN(combo));
set_entry(d.base, 2, label, "2..36");
g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL);
gtk_combo_box_text_append_text(combo, "2");
gtk_combo_box_text_append_text(combo, "8");
gtk_combo_box_text_append_text(combo, "10");
gtk_combo_box_text_append_text(combo, "16");
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1);
gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE);
#else
gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
#endif
label = gtk_label_new(_("Letters:"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_grid_attach(grid, label, 3, 1, 1, 1);
upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper"));
gtk_widget_set_tooltip_text(upper, case_tip);
gtk_grid_attach(grid, upper, 4, 1, 1, 1);
d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper));
gtk_widget_set_tooltip_text(label, case_tip);
label = gtk_label_new_with_mnemonic(_("_Lower"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_container_add(GTK_CONTAINER(d.lower), label);
gtk_grid_attach(grid, d.lower, 5, 1, 1, 1);
d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix"));
gtk_widget_set_tooltip_text(d.prefix,
_("0 for octal, 0x for hex, + for positive decimal"));
gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1);
label = gtk_label_new(_("Padding:"));
gtk_grid_attach(grid, label, 3, 2, 1, 1);
space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace"));
gtk_grid_attach(grid, space, 4, 2, 1, 1);
d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space));
label = gtk_label_new_with_mnemonic(_("_Zero"));
gtk_container_add(GTK_CONTAINER(d.zero), label);
gtk_grid_attach(grid, d.zero, 5, 2, 1, 1);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button,
TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default(button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default(button);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value);
base_text = g_strdup_printf("%d", base_value);
gtk_entry_set_text(GTK_ENTRY(d.base), base_text);
g_free(base_text);
gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix);
gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space));
gtk_widget_show_all(d.dialog);
result = gtk_dialog_run(GTK_DIALOG(d.dialog));
if (result == GTK_RESPONSE_ACCEPT)
{
if (can_insert_numbers())
{
if (end_line - start_line < 1000)
{
/* quick version */
gtk_widget_hide(d.dialog);
insert_numbers(NULL);
}
else
{
gboolean cancel = FALSE;
gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE);
gtk_widget_set_sensitive(button, FALSE);
update_display();
g_signal_connect(d.dialog, "response",
G_CALLBACK(on_insert_numbers_response), &cancel);
insert_numbers(&cancel);
}
}
else
plugin_beep(); /* reloaded or something */
}
gtk_widget_destroy(d.dialog);
}
bool LoaderConstraintTable::add_entry(symbolHandle class_name,
klassOop klass1, Handle class_loader1,
klassOop klass2, Handle class_loader2) {
int failure_code = 0; // encode different reasons for failing
if (klass1 != NULL && klass2 != NULL && klass1 != klass2) {
failure_code = 1;
} else {
klassOop klass = klass1 != NULL ? klass1 : klass2;
LoaderConstraintEntry** pp1 = find_loader_constraint(class_name,
class_loader1);
if (*pp1 != NULL && (*pp1)->klass() != NULL) {
if (klass != NULL) {
if (klass != (*pp1)->klass()) {
failure_code = 2;
}
} else {
klass = (*pp1)->klass();
}
}
LoaderConstraintEntry** pp2 = find_loader_constraint(class_name,
class_loader2);
if (*pp2 != NULL && (*pp2)->klass() != NULL) {
if (klass != NULL) {
if (klass != (*pp2)->klass()) {
failure_code = 3;
}
} else {
klass = (*pp2)->klass();
}
}
if (failure_code == 0) {
if (*pp1 == NULL && *pp2 == NULL) {
unsigned int hash = compute_hash(class_name);
int index = hash_to_index(hash);
LoaderConstraintEntry* p;
p = new_entry(hash, class_name(), klass, 2, 2);
p->set_loaders(NEW_C_HEAP_ARRAY(oop, 2));
p->set_loader(0, class_loader1());
p->set_loader(1, class_loader2());
p->set_klass(klass);
p->set_next(bucket(index));
set_entry(index, p);
if (TraceLoaderConstraints) {
ResourceMark rm;
tty->print("[Adding new constraint for name: %s, loader[0]: %s,"
" loader[1]: %s ]\n",
class_name()->as_C_string(),
SystemDictionary::loader_name(class_loader1()),
SystemDictionary::loader_name(class_loader2())
);
}
} else if (*pp1 == *pp2) {
/* constraint already imposed */
if ((*pp1)->klass() == NULL) {
(*pp1)->set_klass(klass);
if (TraceLoaderConstraints) {
ResourceMark rm;
tty->print("[Setting class object in existing constraint for"
" name: %s and loader %s ]\n",
class_name()->as_C_string(),
SystemDictionary::loader_name(class_loader1())
);
}
} else {
assert((*pp1)->klass() == klass, "loader constraints corrupted");
}
} else if (*pp1 == NULL) {
extend_loader_constraint(*pp2, class_loader1, klass);
} else if (*pp2 == NULL) {
extend_loader_constraint(*pp1, class_loader2, klass);
} else {
merge_loader_constraints(pp1, pp2, klass);
}
}
}
if (failure_code != 0 && TraceLoaderConstraints) {
ResourceMark rm;
const char* reason = "";
switch(failure_code) {
case 1: reason = "the class objects presented by loader[0] and loader[1]"
" are different"; break;
case 2: reason = "the class object presented by loader[0] does not match"
" the stored class object in the constraint"; break;
case 3: reason = "the class object presented by loader[1] does not match"
" the stored class object in the constraint"; break;
default: reason = "unknown reason code";
}
tty->print("[Failed to add constraint for name: %s, loader[0]: %s,"
" loader[1]: %s, Reason: %s ]\n",
class_name()->as_C_string(),
SystemDictionary::loader_name(class_loader1()),
SystemDictionary::loader_name(class_loader2()),
reason
);
}
return failure_code == 0;
}
int main(int argc, char* argv[])
{
GError* err = NULL;
gtk_init(&argc, &argv);
gBuilder = gtk_builder_new();
if (!gtk_builder_add_from_file(gBuilder, gTemplatePath, &err))
{
printf("Erro ao carregar layout: %s\n", err->message);
g_free(err);
return 0;
}
gWindow = GTK_WIDGET(gtk_builder_get_object(gBuilder, "window"));
g_signal_connect(gWindow, "destroy", G_CALLBACK(gtk_main_quit), NULL);
{ // Setting up Spin Buttons
set_spin_btn(&gSpinCF, "spinCF");
set_spin_btn(&gSpinPH, "spinPH");
set_spin_btn(&gSpinDBO, "spinDBO");
set_spin_btn(&gSpinNT, "spinNT");
set_spin_btn(&gSpinFT, "spinFT");
set_spin_btn(&gSpinDT, "spinDT");
set_spin_btn(&gSpinTU, "spinTU");
set_spin_btn(&gSpinOD, "spinOD");
set_spin_btn(&gSpinST, "spinST");
set_spin_btn_value(&gSpinCF, IQA_CF_WEIGHT);
set_spin_btn_value(&gSpinPH, IQA_PH_WEIGHT);
set_spin_btn_value(&gSpinDBO, IQA_DBO_WEIGHT);
set_spin_btn_value(&gSpinNT, IQA_NT_WEIGHT);
set_spin_btn_value(&gSpinFT, IQA_FT_WEIGHT);
set_spin_btn_value(&gSpinDT, IQA_DT_WEIGHT);
set_spin_btn_value(&gSpinTU, IQA_TU_WEIGHT);
set_spin_btn_value(&gSpinOD, IQA_O2_WEIGHT);
set_spin_btn_value(&gSpinST, IQA_ST_WEIGHT);
}
{ // Setting up Entries
set_entry(&gEntryCF, "entryCF");
set_entry(&gEntryPH, "entryPH");
set_entry(&gEntryDBO, "entryDBO");
set_entry(&gEntryNT, "entryNT");
set_entry(&gEntryFT, "entryFT");
set_entry(&gEntryDT, "entryDT");
set_entry(&gEntryTU, "entryTU");
set_entry(&gEntryOD, "entryOD");
set_entry(&gEntryST, "entryST");
set_entry(&gEntryIQA, "entryIQA");
set_entry(&gEntryIQAIndex, "entryIQAIndex");
}
{ // Setting up buttons
set_btn(&gBtnCalculate, "btnCalculate");
set_btn(&gBtnClean, "btnClean");
set_btn(&gBtnReport, "btnReport");
set_btn(&gBtnAbout, "btnAbout");
// Button actions
g_signal_connect(gBtnCalculate, "clicked", G_CALLBACK(calculate_iqa), NULL);
}
gtk_widget_show_all(gWindow);
gtk_main();
return 0;
}
void
PathHandler::_EntryMoved(BMessage* message)
{
// has the entry been moved into a monitored directory or has
// it been removed from one?
const char* name;
node_ref nodeRef;
uint64 fromNode;
uint64 node;
if (message->FindInt32("device", &nodeRef.device) != B_OK
|| message->FindInt64("to directory", &nodeRef.node) != B_OK
|| message->FindInt64("from directory", (int64 *)&fromNode) != B_OK
|| message->FindInt64("node", (int64 *)&node) != B_OK
|| message->FindString("name", &name) != B_OK)
return;
BEntry entry;
if (set_entry(nodeRef, name, entry) != B_OK)
return;
bool entryContained = _IsContained(entry);
bool wasAdded = false;
bool wasRemoved = false;
bool notify = false;
bool parentContained;
if (_HasDirectory(nodeRef, &parentContained)) {
// something has been added to our watched directories
nodeRef.node = node;
TRACE(" ADDED TO PARENT (%d), has entry %d/%d, entry %d %d\n",
parentContained, _HasDirectory(nodeRef), _HasFile(nodeRef),
entryContained, _CloserToPath(entry));
if (entry.IsDirectory()) {
if (!_HasDirectory(nodeRef)
&& (entryContained || _CloserToPath(entry))) {
// there is a new directory to watch for us
if (entryContained
|| (parentContained && !_WatchRecursively())) {
_AddDirectory(entry, true);
// NOTE: entry is toast now!
} else if (_GetClosest(fPath.Path(), false,
nodeRef) == B_OK) {
// the new directory might put us even
// closer to the path we are after
_AddDirectory(nodeRef, true);
}
wasAdded = true;
notify = entryContained;
}
if (_WatchFilesOnly())
notify = false;
} else if (!_HasFile(nodeRef) && entryContained) {
// file has been added
wasAdded = true;
notify = true;
_AddFile(entry);
}
} else {
// and entry has been removed from our directories
wasRemoved = true;
nodeRef.node = node;
if (entry.IsDirectory()) {
if (_HasDirectory(nodeRef, ¬ify))
_RemoveDirectory(entry, fromNode);
if (_WatchFilesOnly())
notify = false;
} else {
_RemoveFile(entry);
notify = true;
}
}
if (notify) {
if (wasAdded)
message->AddBool("added", true);
if (wasRemoved)
message->AddBool("removed", true);
_NotifyTarget(message, nodeRef);
}
}
static int
do_mod_entry(krb5_principal principal, void *data)
{
krb5_error_code ret;
kadm5_principal_ent_rec princ;
int mask = 0;
struct modify_options *e = data;
memset (&princ, 0, sizeof(princ));
ret = kadm5_get_principal(kadm_handle, principal, &princ,
KADM5_PRINCIPAL | KADM5_ATTRIBUTES |
KADM5_MAX_LIFE | KADM5_MAX_RLIFE |
KADM5_PRINC_EXPIRE_TIME |
KADM5_PW_EXPIRATION);
if(ret)
return ret;
if(e->max_ticket_life_string ||
e->max_renewable_life_string ||
e->expiration_time_string ||
e->pw_expiration_time_string ||
e->attributes_string ||
e->policy_string ||
e->kvno_integer != -1 ||
e->constrained_delegation_strings.num_strings ||
e->alias_strings.num_strings ||
e->pkinit_acl_strings.num_strings ||
e->hist_kvno_diff_clnt_integer != -1 ||
e->hist_kvno_diff_svc_integer != -1) {
ret = set_entry(context, &princ, &mask,
e->max_ticket_life_string,
e->max_renewable_life_string,
e->expiration_time_string,
e->pw_expiration_time_string,
e->attributes_string,
e->policy_string);
if(e->kvno_integer != -1) {
princ.kvno = e->kvno_integer;
mask |= KADM5_KVNO;
}
if (e->constrained_delegation_strings.num_strings) {
add_constrained_delegation(context, &princ,
&e->constrained_delegation_strings);
mask |= KADM5_TL_DATA;
}
if (e->alias_strings.num_strings) {
add_aliases(context, &princ, &e->alias_strings);
mask |= KADM5_TL_DATA;
}
if (e->pkinit_acl_strings.num_strings) {
add_pkinit_acl(context, &princ, &e->pkinit_acl_strings);
mask |= KADM5_TL_DATA;
}
if (e->hist_kvno_diff_clnt_integer != -1) {
add_kvno_diff(context, &princ, 0, e->hist_kvno_diff_clnt_integer);
mask |= KADM5_TL_DATA;
}
if (e->hist_kvno_diff_svc_integer != -1) {
add_kvno_diff(context, &princ, 1, e->hist_kvno_diff_clnt_integer);
mask |= KADM5_TL_DATA;
}
} else
ret = edit_entry(&princ, &mask, NULL, 0);
if(ret == 0) {
ret = kadm5_modify_principal(kadm_handle, &princ, mask);
if(ret)
krb5_warn(context, ret, "kadm5_modify_principal");
}
kadm5_free_principal_ent(kadm_handle, &princ);
return ret;
}
static krb5_error_code
add_one_principal (const char *name,
int rand_key,
int rand_password,
int use_defaults,
char *password,
krb5_key_data *key_data,
const char *max_ticket_life,
const char *max_renewable_life,
const char *attributes,
const char *expiration,
const char *pw_expiration)
{
krb5_error_code ret;
kadm5_principal_ent_rec princ, defrec;
kadm5_principal_ent_rec *default_ent = NULL;
krb5_principal princ_ent = NULL;
int mask = 0;
int default_mask = 0;
char pwbuf[1024];
memset(&princ, 0, sizeof(princ));
ret = krb5_parse_name(context, name, &princ_ent);
if (ret) {
krb5_warn(context, ret, "krb5_parse_name");
return ret;
}
princ.principal = princ_ent;
mask |= KADM5_PRINCIPAL;
ret = set_entry(context, &princ, &mask,
max_ticket_life, max_renewable_life,
expiration, pw_expiration, attributes);
if (ret)
goto out;
default_ent = &defrec;
ret = get_default (kadm_handle, princ_ent, default_ent);
if (ret) {
default_ent = NULL;
default_mask = 0;
} else {
default_mask = KADM5_ATTRIBUTES | KADM5_MAX_LIFE | KADM5_MAX_RLIFE |
KADM5_PRINC_EXPIRE_TIME | KADM5_PW_EXPIRATION;
}
if(use_defaults)
set_defaults(&princ, &mask, default_ent, default_mask);
else
if(edit_entry(&princ, &mask, default_ent, default_mask))
goto out;
if(rand_key || key_data) {
princ.attributes |= KRB5_KDB_DISALLOW_ALL_TIX;
mask |= KADM5_ATTRIBUTES;
random_password (pwbuf, sizeof(pwbuf));
password = pwbuf;
} else if (rand_password) {
random_password (pwbuf, sizeof(pwbuf));
password = pwbuf;
} else if(password == NULL) {
char *princ_name;
char *prompt;
krb5_unparse_name(context, princ_ent, &princ_name);
asprintf (&prompt, "%s's Password: "******"failed to verify password");
goto out;
}
password = pwbuf;
}
ret = kadm5_create_principal(kadm_handle, &princ, mask, password);
if(ret) {
krb5_warn(context, ret, "kadm5_create_principal");
goto out;
}
if(rand_key) {
krb5_keyblock *new_keys;
int n_keys, i;
ret = kadm5_randkey_principal(kadm_handle, princ_ent,
&new_keys, &n_keys);
if(ret){
krb5_warn(context, ret, "kadm5_randkey_principal");
n_keys = 0;
}
for(i = 0; i < n_keys; i++)
krb5_free_keyblock_contents(context, &new_keys[i]);
if (n_keys > 0)
free(new_keys);
kadm5_get_principal(kadm_handle, princ_ent, &princ,
KADM5_PRINCIPAL | KADM5_KVNO | KADM5_ATTRIBUTES);
princ.attributes &= (~KRB5_KDB_DISALLOW_ALL_TIX);
princ.kvno = 1;
kadm5_modify_principal(kadm_handle, &princ,
KADM5_ATTRIBUTES | KADM5_KVNO);
kadm5_free_principal_ent(kadm_handle, &princ);
} else if (key_data) {
ret = kadm5_chpass_principal_with_key (kadm_handle, princ_ent,
3, key_data);
if (ret) {
krb5_warn(context, ret, "kadm5_chpass_principal_with_key");
}
kadm5_get_principal(kadm_handle, princ_ent, &princ,
KADM5_PRINCIPAL | KADM5_ATTRIBUTES);
princ.attributes &= (~KRB5_KDB_DISALLOW_ALL_TIX);
kadm5_modify_principal(kadm_handle, &princ, KADM5_ATTRIBUTES);
kadm5_free_principal_ent(kadm_handle, &princ);
} else if (rand_password) {
char *princ_name;
krb5_unparse_name(context, princ_ent, &princ_name);
printf ("added %s with password \"%s\"\n", princ_name, password);
free (princ_name);
}
out:
if (princ_ent)
krb5_free_principal (context, princ_ent);
if(default_ent)
kadm5_free_principal_ent (kadm_handle, default_ent);
if (password != NULL)
memset (password, 0, strlen(password));
return ret;
}
void
jam_doc_load_entry(JamDoc *doc, LJEntry *entry) {
set_entry(doc, lj_entry_copy(entry));
g_signal_emit_by_name(doc, "entry_changed");
}
