void uart_init(void) { /* TODO the divisor calculation is hard coded to standard UARTs. Some * UARTs won't work with these values. This should be a property of the * UART used, worst case a Kconfig variable. For now live with hard * codes as the only devices that might be different are the iWave * iRainbowG6 and the OXPCIe952 card (and the latter is memory mapped) */ unsigned int div = (115200 / CONFIG_TTYS0_BAUD); #if !defined(__SMM__) && CONFIG_USE_OPTION_TABLE static const unsigned char divisor[8] = { 1, 2, 3, 6, 12, 24, 48, 96 }; unsigned b_index = 0; #if defined(__PRE_RAM__) b_index = read_option(baud_rate, 0); b_index &= 7; div = divisor[b_index]; #else if (get_option(&b_index, "baud_rate") == CB_SUCCESS) div = divisor[b_index]; #endif #endif uart8250_init(CONFIG_TTYS0_BASE, div); }
list *read_cfg(char *filename) { FILE *file = fopen(filename, "r"); if(file == 0) file_error(filename); char *line; int nu = 0; list *sections = make_list(); section *current = 0; while((line=fgetl(file)) != 0){ ++ nu; strip(line); switch(line[0]){ case '[': current = malloc(sizeof(section)); list_insert(sections, current); current->options = make_list(); current->type = line; break; case '\0': case '#': case ';': free(line); break; default: if(!read_option(line, current->options)){ fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line); free(line); } break; } } fclose(file); return sections; }
list *read_data_cfg(char *filename) { FILE *file = fopen(filename, "r"); if(file == 0) file_error(filename); char *line; int nu = 0; list *options = make_list(); while((line=fgetl(file)) != 0){ ++ nu; strip(line); switch(line[0]){ case '\0': case '#': case ';': free(line); break; default: if(!read_option(line, options)){ fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line); free(line); } break; } } fclose(file); return options; }
static void ms7135_set_ram_voltage(void) { u8 b; b = read_option(ram_voltage, 0); if (b > 4) /* default if above 2.70v */ b = 0; printk(BIOS_INFO, "setting RAM voltage %08x\n", b); ck804_smbus_write_byte(1, 0x2f, 0x00, b); }
static void ms7135_set_nf4_voltage(void) { u8 b; b = read_option(nf4_voltage, 0); if (b > 2) /* default if above 1.60v */ b = 0; b |= 0x10; printk(BIOS_INFO, "setting NF4 voltage %08x\n", b); ck804_smbus_write_byte(1, 0x2f, 0x02, b); }
void uart_init(void) { #if CONFIG_USE_OPTION_TABLE static const unsigned char divisor[] = { 1,2,3,6,12,24,48,96 }; unsigned ttys0_div, ttys0_index; ttys0_index = read_option(CMOS_VSTART_baud_rate, CMOS_VLEN_baud_rate, 0); ttys0_index &= 7; ttys0_div = divisor[ttys0_index]; uart8250_init(CONFIG_TTYS0_BASE, ttys0_div, UART_LCS); #else uart8250_init(CONFIG_TTYS0_BASE, CONFIG_TTYS0_DIV, UART_LCS); #endif }
u32 uart_mem_init(void) { unsigned uart_baud = CONFIG_TTYS0_BAUD; u32 uart_bar = 0; unsigned div; /* find out the correct baud rate */ #if !defined(__SMM__) && CONFIG_USE_OPTION_TABLE static const unsigned baud[8] = { 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200 }; unsigned b_index = 0; #if defined(__PRE_RAM__) b_index = read_option(baud_rate, 0); b_index &= 7; uart_baud = baud[b_index]; #else if (get_option(&b_index, "baud_rate") == CB_SUCCESS) uart_baud = baud[b_index]; #endif #endif /* Now find the UART base address and calculate the divisor */ #if CONFIG_DRIVERS_OXFORD_OXPCIE #if defined(MORE_TESTING) && !defined(__SIMPLE_DEVICE__) device_t dev = dev_find_device(0x1415, 0xc158, NULL); if (!dev) dev = dev_find_device(0x1415, 0xc11b, NULL); if (dev) { struct resource *res = find_resource(dev, 0x10); if (res) { uart_bar = res->base + 0x1000; // for 1st UART // uart_bar = res->base + 0x2000; // for 2nd UART } } if (!uart_bar) #endif uart_bar = CONFIG_OXFORD_OXPCIE_BASE_ADDRESS + 0x1000; // 1st UART // uart_bar = CONFIG_OXFORD_OXPCIE_BASE_ADDRESS + 0x2000; // 2nd UART div = 4000000 / uart_baud; #endif if (uart_bar) uart8250_mem_init(uart_bar, div); return uart_bar; }
//it is running on core0 of node0 static inline void start_other_cores(void) { unsigned nodes; unsigned nodeid; if (read_option(multi_core, 0)) { return; // disable multi_core } nodes = get_nodes(); for (nodeid=0; nodeid<nodes; nodeid++) { if ( get_core_num_in_bsp(nodeid) > 0) { real_start_other_core(nodeid); } } }
unsigned int default_baudrate(void) { #if !defined(__SMM__) && CONFIG_USE_OPTION_TABLE static const unsigned baud[8] = { 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200 }; unsigned b_index = 0; #if defined(__PRE_RAM__) b_index = read_option(baud_rate, 0xff); #else if (get_option(&b_index, "baud_rate") != CB_SUCCESS) b_index = 0xff; #endif if (b_index < 8) return baud[b_index]; #endif return CONFIG_TTYS0_BAUD; }
static void ich7_enable_lpc(void) { int lpt_en = 0; if (read_option(lpt, 0) != 0) { lpt_en = 1 << 2; // enable LPT } // Enable Serial IRQ pci_write_config8(PCI_DEV(0, 0x1f, 0), 0x64, 0xd0); // decode range pci_write_config16(PCI_DEV(0, 0x1f, 0), 0x80, 0x0007); // decode range pci_write_config16(PCI_DEV(0, 0x1f, 0), 0x82, 0x3f0b | lpt_en); // Enable 0x02e0 - 0x2ff pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x84, 0x001c02e1); // Enable 0x600 - 0x6ff pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x88, 0x00fc0601); // Enable 0x68 - 0x6f pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x8c, 0x00040069); }
int main(int ac, char **av) { t_env *e; e = init_env(); read_option(e, ac, av); if (!(e->mlx.win = mlx_new_window(e->mlx.mlx, WIDTH, HEIGHT, "WOLF3D"))) { ft_putendl("ERROR CREATING WINDOW"); return (-1); } usable_key(); mlx_do_key_autorepeatoff(e->mlx.mlx); mlx_loop_hook(e->mlx.mlx, loop_hook, e); mlx_hook(e->mlx.win, PRESS, PRESS_MASK, key_press, e); mlx_key_hook(e->mlx.win, key_hook, e); mlx_loop(e->mlx.mlx); return (0); }
static twin_bool_t pboot_proc_client_sock(int sock, twin_file_op_t ops, void *closure) { struct device_context *dev_ctx = closure; uint8_t action; if (read_action(sock, &action)) goto out_err; if (action == DEV_ACTION_ADD_DEVICE) { if (!read_device(sock, dev_ctx)) goto out_err; } else if (action == DEV_ACTION_ADD_OPTION) { if (dev_ctx->device_idx == -1) { LOG("option, but no device has been sent?\n"); goto out_err; } if (!read_option(sock, dev_ctx)) goto out_err; } else if (action == DEV_ACTION_REMOVE_DEVICE) { char *dev_id = read_string(sock); if (!dev_id) goto out_err; LOG("remove device %s\n", dev_id); pboot_remove_device(dev_id); } else { LOG("unsupported action %d\n", action); goto out_err; } return TWIN_TRUE; out_err: close(sock); return TWIN_FALSE; }
static void ich7_enable_lpc(void) { int lpt_en = 0; if (read_option(lpt, 0) != 0) { lpt_en = 1<<2; // enable LPT } // Enable Serial IRQ pci_write_config8(PCI_DEV(0, 0x1f, 0), 0x64, 0xd0); // Set COM1/COM2 decode range pci_write_config16(PCI_DEV(0, 0x1f, 0), 0x80, 0x0010); // Enable COM1/COM2/KBD/SuperIO1+2 pci_write_config16(PCI_DEV(0, 0x1f, 0), 0x82, 0x340b | lpt_en); // Enable HWM at 0xa00 pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x84, 0x00fc0a01); // COM3 decode pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x88, 0x000403e9); // COM4 decode pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x8c, 0x000402e9); // io 0x300 decode pci_write_config32(PCI_DEV(0, 0x1f, 0), 0x90, 0x00000301); }
static void ich7_enable_lpc(void) { int lpt_en = 0; if (read_option(lpt, 0) != 0) lpt_en = LPT_LPC_EN; // Enable Serial IRQ pci_write_config8(PCI_DEV(0, 0x1f, 0), SERIRQ_CNTL, 0xd0); // decode range pci_write_config16(PCI_DEV(0, 0x1f, 0), LPC_IO_DEC, 0x0007); // decode range pci_write_config16(PCI_DEV(0, 0x1f, 0), LPC_EN, CNF2_LPC_EN | CNF1_LPC_EN | MC_LPC_EN | KBC_LPC_EN | GAMEH_LPC_EN | GAMEL_LPC_EN | FDD_LPC_EN| lpt_en | COMB_LPC_EN | COMA_LPC_EN); // Enable 0x02e0 - 0x2ff pci_write_config32(PCI_DEV(0, 0x1f, 0), GEN1_DEC, 0x001c02e1); // Enable 0x600 - 0x6ff pci_write_config32(PCI_DEV(0, 0x1f, 0), GEN2_DEC, 0x00fc0601); // Enable 0x68 - 0x6f pci_write_config32(PCI_DEV(0, 0x1f, 0), GEN3_DEC, 0x00040069); }
void uart_init(void) { /* disable interrupts */ outb(0x0, CONFIG_TTYS0_BASE + UART_IER); /* enable fifo's */ outb(0x01, CONFIG_TTYS0_BASE + UART_FCR); /* Set Baud Rate Divisor to 12 ==> 115200 Baud */ outb(0x80 | UART_LCS, CONFIG_TTYS0_BASE + UART_LCR); #if CONFIG_USE_OPTION_TABLE static const unsigned char divisor[] = { 1,2,3,6,12,24,48,96 }; unsigned ttys0_div, ttys0_index; ttys0_index = read_option(CMOS_VSTART_baud_rate, CMOS_VLEN_baud_rate, 0); ttys0_index &= 7; ttys0_div = divisor[ttys0_index]; outb(ttys0_div & 0xff, CONFIG_TTYS0_BASE + UART_DLL); outb(0, CONFIG_TTYS0_BASE + UART_DLM); #else outb(CONFIG_TTYS0_DIV & 0xFF, CONFIG_TTYS0_BASE + UART_DLL); outb((CONFIG_TTYS0_DIV >> 8) & 0xFF, CONFIG_TTYS0_BASE + UART_DLM); #endif outb(UART_LCS, CONFIG_TTYS0_BASE + UART_LCR); }
/* * Read a switch configuration */ SWITCH * switch_conf() { char *keyword; char *argument; int token; SWITCH *sw; char *name; struct switch_attributes *attributes; sw = (SWITCH *) malloc(sizeof(SWITCH)); if (sw == NULL) { config_error("malloc() failed.\n"); exit(1); } name = read_option(); /* Read name */ argument = read_option(); /* Read type */ if ((name == NULL) || (argument == NULL)) { config_error("Name and type required for switch. Skipping.\n"); next_keyword(); return NULL; } sw->sw_type = parse_token(argument, switch_keywords); if (sw->sw_type == TOKEN_NOT_FOUND) { config_error("Switch type \"%s\" unknown. Assuming PS32.\n", argument); sw->sw_type = HIPPISW_PS32; } /* * Fill in defaults */ strncpy(sw->sw_name, name, SWNAMELEN); sw->sw_version = 1; /* Set a bunch of stuff here in one wave of the hand */ attributes = get_sw_attributes(sw->sw_type); bcopy(attributes, &(sw->sw_attributes), sizeof(sw->sw_attributes)); sw->sw_ports = NULL; NULL_STRING(sw->sw_hostname); sw->sw_tport = TELNET_PORT; sw->sw_linenum = parsed_linenumber(); NULL_STRING(sw->sw_comment); sw->sw_virt_attached = NULL; NULL_STRING(sw->sw_password); /* * Read rest of options */ while ((keyword = read_option()) != NULL) { if ((token = parse_token(keyword, keywords)) == TOKEN_NOT_FOUND) { config_error("\"%s\" is not recognized. Skipping.\n", keyword); continue; } /* Currently all options take arguments */ argument = read_option(); if (argument == NULL) { config_error("Argument required for %s option.\n", keyword); continue; } switch(token) { case KEYWD_SIZE: if (is_numeric(argument) == FALSE) { config_error("\"%s\" is not a legal numeric argument. Skipping.\n", argument); continue; } sw->sw_num_ports = str_to_int(argument); break; case KEYWD_ADDRESS: if (hostname_to_netaddr(argument) == NETADDR_NULL) config_error("Warning: can't resolve net address for \"%s\".\n", argument); strncpy(sw->sw_hostname, argument, HNAMELEN); break; case KEYWD_PORT: if (is_numeric(argument) == FALSE) { config_error("\"%s\" is not a legal numeric argument. Skipping.\n", argument); continue; } sw->sw_tport = str_to_int(argument); break; case KEYWD_PROMPT: config_error("\"prompt\" no longer supported. Skipping.\n"); break; case KEYWD_SMS: if (is_numeric(argument) == FALSE) { config_error("\"%s\" is not a legal numeric argument. Skipping.\n", argument); continue; } sw->sw_version = str_to_int(argument); break; case KEYWD_COMMENT: strncpy(sw->sw_comment, argument, COMMENTLEN); break; case KEYWD_START_LOG: config_error("\"start_log\" no longer supported.\n"); continue; } } if ((sw->sw_num = add_switch(sw)) == ERROR) { config_error("Error adding switch to list.\n"); exit(1); } return sw; }
void cache_as_ram_main(unsigned long bist, unsigned long cpu_init_detectedx) { static const u16 spd_addr[] = { DIMM0, 0, 0, 0, DIMM1, 0, 0, 0, }; int needs_reset = 0; u32 bsp_apicid = 0; msr_t msr; struct cpuid_result cpuid1; struct sys_info *sysinfo = &sysinfo_car; if (!cpu_init_detectedx && boot_cpu()) { /* Nothing special needs to be done to find bus 0 */ /* Allow the HT devices to be found */ enumerate_ht_chain(); /* sb600_lpc_port80(); */ sb600_pci_port80(); } if (bist == 0) { bsp_apicid = init_cpus(cpu_init_detectedx, sysinfo); } enable_rs690_dev8(); // enable CFG access to Dev8, which is the SB P2P Bridge sb600_lpc_init(); #if defined(DUMP_CMOS_RAM) && (DUMP_CMOS_RAM == 0) check_cmos(); // rebooting in case of corrupted cmos !!!!! #endif /* it8712f_enable_serial does not use its 1st parameter. */ it8712f_enable_serial(0, CONFIG_TTYS0_BASE); it8712f_kill_watchdog(); console_init(); #if defined(DUMP_CMOS_RAM) && (DUMP_CMOS_RAM == 1) check_cmos(); // rebooting in case of corrupted cmos !!!!! #endif post_code(0x03); /* Halt if there was a built in self test failure */ report_bist_failure(bist); __DEBUG__("bsp_apicid=0x%x\n", bsp_apicid); setup_sitemp_resource_map(); setup_coherent_ht_domain(); #if CONFIG_LOGICAL_CPUS /* It is said that we should start core1 after all core0 launched */ wait_all_core0_started(); start_other_cores(); #endif wait_all_aps_started(bsp_apicid); ht_setup_chains_x(sysinfo); /* run _early_setup before soft-reset. */ rs690_early_setup(); sb600_early_setup(); post_code(0x04); /* Check to see if processor is capable of changing FIDVID */ /* otherwise it will throw a GP# when reading FIDVID_STATUS */ cpuid1 = cpuid(0x80000007); if( (cpuid1.edx & 0x6) == 0x6 ) { /* Read FIDVID_STATUS */ msr=rdmsr(0xc0010042); __DEBUG__("begin msr fid, vid: hi=0x%x, lo=0x%x\n", msr.hi, msr.lo); enable_fid_change(); enable_fid_change_on_sb(sysinfo->sbbusn, sysinfo->sbdn); init_fidvid_bsp(bsp_apicid); /* show final fid and vid */ msr=rdmsr(0xc0010042); __DEBUG__("end msr fid, vid: hi=0x%x, lo=0x%x\n", msr.hi, msr.lo); } else { __DEBUG__("Changing FIDVID not supported\n"); } post_code(0x05); needs_reset = optimize_link_coherent_ht(); needs_reset |= optimize_link_incoherent_ht(sysinfo); rs690_htinit(); __DEBUG__("needs_reset=0x%x\n", needs_reset); post_code(0x06); if (needs_reset) { __INFO__("ht reset -\n"); soft_reset(); } allow_all_aps_stop(bsp_apicid); /* It's the time to set ctrl now; */ __DEBUG__("sysinfo->nodes: %2x sysinfo->ctrl: %p spd_addr: %p\n", sysinfo->nodes, sysinfo->ctrl, spd_addr); fill_mem_ctrl(sysinfo->nodes, sysinfo->ctrl, spd_addr); post_code(0x07); sdram_initialize(sysinfo->nodes, sysinfo->ctrl, sysinfo); post_code(0x08); rs690_before_pci_init(); // does nothing sb600_before_pci_init(); #if CONFIG_USE_OPTION_TABLE if( read_option(cmos_defaults_loaded, 0) ) __WARNING__("WARNING: CMOS DEFAULTS LOADED. PLEASE CHECK CMOS OPTION \"cmos_default_loaded\" !\n"); #endif post_cache_as_ram(); }
void isom_options (int format, struct pcp_vars *pcp) { register int *y = y_address; FILE *Status; FILE *FileName; FILE *Subgroup; struct pga_vars pga; Logical user_supplied = FALSE; Logical group_present = FALSE; Logical identity_map; Logical finished; Logical valid; Logical equal; int output = DEFAULT_STANDARD_PRINT; int start_class, final_class; int option; int t; int status; int complete; int iteration; int *seq1; int *seq2; int len1, len2; int nmr_items; int ***auts; int x_dim, y_dim; FILE * GAP_library; char *name; int nmr_of_exponents; StandardPresentation = TRUE; pga.nmr_soluble = 0; list_isom_menu (); do { option = read_option (MAXOPTION); switch (option) { case -1: list_isom_menu (); break; case START_INFO: t = runTime (); group_present = setup_start_info (FALSE, 0, stdin, format, &pga, pcp); handle_error (group_present); user_supplied = TRUE; t = runTime () - t; /* it is possible that the p-quotient is trivial */ if (pcp->cc == 0) { group_present = FALSE; break; } printf ("Class %d %d-quotient and its %d-covering group computed in %.2f seconds\n", pcp->cc - 1, pcp->p, pcp->p, t * CLK_SCALE); break; case CONSTRUCT: if (!user_supplied) { name = GetString ("Enter input file name for group information: "); FileName = OpenFile (name, "r"); if (FileName == NULL) break; } name = GetString ("Enter output file name for group information: "); read_value (TRUE, "Standardise presentation to what class? ", &final_class, 0); if (user_supplied && final_class < pcp->cc) { printf ("Value supplied for end class must be at least %d\n", pcp->cc); } /* read in data from file and set up group to end of start_class and compute its p-covering group */ if (!user_supplied) { group_present = setup_start_info (FALSE, 0, FileName, FILE_INPUT, &pga, pcp); handle_error (group_present); if (final_class < pcp->cc) { CloseFile (FileName); printf ("Value supplied for end class must be at least %d\n", pcp->cc); } } if (pcp->cc == 0) { printf ("%d-quotient is trivial\n", pcp->p); break; } complete = (pcp->newgen == 0) ? TERMINAL : CAPABLE; iteration = 0; for (start_class = pcp->cc; start_class <= final_class && complete != TERMINAL; ++start_class) { t = runTime (); identity_map = FALSE; Subgroup = OpenFile ("ISOM_Subgroup", "w"); do { ++iteration; set_defaults (&pga); /* pga.space_efficient = TRUE; */ /* either prompt for information or read it from file */ if (user_supplied) { auts = read_auts (STANDARDISE, &pga.m, &nmr_of_exponents, pcp) ; pga.fixed = 0; query_solubility (&pga); user_supplied = FALSE; #ifdef HAVE_GMP autgp_order (&pga, pcp); #endif } else { auts = read_auts_from_file (FileName, &pga.m, pcp); nmr_items = fscanf (FileName, "%d", &pga.fixed); verify_read (nmr_items, 1); nmr_items = fscanf (FileName, "%d", &pga.soluble); verify_read (nmr_items, 1); #ifdef HAVE_GMP fscanf (FileName, "\n"); mpz_init (&pga.aut_order); mpz_inp_str (&pga.aut_order, FileName, 10); #endif CloseFile (FileName); } x_dim = pga.m; y_dim = pcp->lastg; /* construct standard presentation relative to smallest permissible characteristic subgroup in p-multiplicator */ standard_presentation (&identity_map, output, auts, &pga, pcp); free_array (auts, x_dim, y_dim, 1); /* was the characteristic subgroup chosen in this iteration the whole of the p-multiplicator? */ Status = OpenFile ("ISOM_Status", "r"); fscanf (Status, "%d", &status); fscanf (Status, "%d", &complete); CloseFile (Status); /* have we finished the construction? */ finished = (status == END_OF_CLASS && (start_class == final_class || complete == TERMINAL)); /* organise to write modified presentation + automorphisms to file ISOM_PP */ if (!identity_map || finished) { copy_file( "ISOM_present", "ISOM_PP" ); append_file( "ISOM_NextClass", "ISOM_PP" ); } else copy_file( "ISOM_NextClass", "ISOM_PP" ); if (finished) break; /* if necessary, set up new presentation + other information */ FileName = OpenFile ("ISOM_PP", "r"); group_present = setup_start_info (identity_map, status, FileName, FILE_INPUT, &pga, pcp); handle_error (group_present); /* if appropriate, factor subgroup from p-multiplicator */ if (status != END_OF_CLASS) factor_subgroup (pcp); /* reinitialise pga structure */ initialise_pga (&pga, pcp); pga.m = 0; pga.ndgen = y[pcp->clend + 1]; set_values (&pga, pcp); } while (status != END_OF_CLASS && complete != TERMINAL); CloseFile (Subgroup); /* the group may have completed only when relations are enforced; this is an attempt to determine this case */ if (pga.nuclear_rank != 0 && pcp->complete) break; t = runTime () - t; printf ("Computing standard presentation for class %d took %.2f seconds\n", start_class, t * CLK_SCALE); } /* we currently may have presentation for p-covering group; or is the starting group terminal? if so, we may want to use last_class to revert to group presentation */ if (!user_supplied && iteration == 0 && !pcp->complete) last_class (pcp); /* is the group terminal? */ if (complete == TERMINAL) printf ("The largest %d-quotient of the group has class %d\n", pcp->p, pcp->cc); if (iteration == 0) break; /* rename file ISOM_PP containing iteration info to nominated file */ rename( "ISOM_PP", name ); break; case PRINT_PCP: if (group_present) print_presentation (TRUE, pcp); break; case SAVE_PRES: name = GetString ("Enter output file name: "); FileName = OpenFileOutput (name); if (group_present && FileName != NULL) { save_pcp (FileName, pcp); CloseFile (FileName); printf ("Presentation written to file\n"); } break; case COMPARE: valid = get_description ("Enter file name storing first presentation: ", &len1, &seq1, pcp); if (!valid) break; valid = get_description ("Enter file name storing second presentation: ", &len2, &seq2, pcp); if (!valid) break; equal = (len1 == len2) ? compare_sequences (seq1, seq2, len1): FALSE; printf ("Identical presentations? %s\n", equal == TRUE ? "True" : "False"); free_vector (seq1, 1); free_vector (seq2, 1); break; case STANDARD_PRINT_LEVEL: read_value (TRUE, "Input print level for construction (0-2): ", &output, 0); /* allow user to supply same max print level as for p-quotient calculations */ if (output == MAX_STANDARD_PRINT + 1) --output; if (output > MAX_STANDARD_PRINT) { printf ("Print level must lie between %d and %d\n", MIN_STANDARD_PRINT, MAX_STANDARD_PRINT); output = DEFAULT_STANDARD_PRINT; } break; case PQ_MENU: options (ISOM_MENU, format, pcp); break; case ISOM_OPTION: FileName = OpenFile (name, "r"); group_present = setup_start_info (FALSE, 0, FileName, FILE_INPUT, &pga, pcp); pcp->multiplicator_rank = pcp->lastg - y[pcp->clend + pcp->cc-1]; last_class (pcp); auts = read_auts_from_file (FileName, &pga.m, pcp); nmr_items = fscanf (FileName, "%d", &pga.fixed); verify_read (nmr_items, 1); nmr_items = fscanf (FileName, "%d", &pga.soluble); verify_read (nmr_items, 1); printf ("Images of user-supplied generators are listed last below\n"); print_map (pcp); #ifdef HAVE_GMP fscanf (FileName, "\n"); mpz_init (&pga.aut_order); mpz_inp_str (&pga.aut_order, FileName, 10); #endif CloseFile (FileName); GAP_library = OpenFile ("GAP_library", "a+"); write_GAP_library (GAP_library, pcp); pga.nmr_centrals = pga.m; pga.nmr_stabilisers = 0; GAP_auts (GAP_library, auts, auts, &pga, pcp); CloseFile (GAP_library); printf ("Presentation listing images of user-supplied generators written to GAP_library\n"); break; case EXIT: case MAXOPTION: unlink( "ISOM_present" ); unlink( "ISOM_Subgroup" ); unlink( "ISOM_cover_file" ); unlink( "ISOM_group_file" ); unlink( "ISOM_XX" ); unlink( "ISOM_NextClass" ); unlink( "ISOM_Status" ); printf ("Exiting from ANU p-Quotient Program\n"); break; } /* switch */ } while (option != 0 && option != MAXOPTION); }
void interactive_pga(Logical group_present, FILE *StartFile, int group_nmr, int ***auts, struct pga_vars *pga, struct pcp_vars *pcp) { struct pga_vars flag; int option; Logical soluble_group = TRUE; FILE *OutputFile = 0; FILE *LINK_input = 0; char *StartName = 0; int t; int **perms = 0; int index; int **S = 0; int k; int K; int label; int *a = 0, *b = 0; char *c = 0; int *orbit_length = 0; int nmr_of_exponents; int *subset = 0; int alpha; int upper_step; int rep; int i; list_interactive_pga_menu(); do { option = read_option(MAX_INTERACTIVE_OPTION); switch (option) { case -1: list_interactive_pga_menu(); break; case SUPPLY_AUTS: auts = read_auts(PGA, &pga->m, &nmr_of_exponents, pcp); #ifdef HAVE_GMP autgp_order(pga, pcp); #endif pga->soluble = TRUE; start_group(&StartFile, auts, pga, pcp); break; case EXTEND_AUTS: extend_automorphisms(auts, pga->m, pcp); print_auts(pga->m, pcp->lastg, auts, pcp); break; case RESTORE_GP: StartName = GetString("Enter input file name: "); StartFile = OpenFileInput(StartName); if (StartFile != NULL) { read_value(TRUE, "Which group? ", &group_nmr, 0); auts = restore_group(TRUE, StartFile, group_nmr, pga, pcp); RESET(StartFile); } break; case DISPLAY_GP: print_presentation(FALSE, pcp); print_structure(1, pcp->lastg, pcp); print_pcp_relations(pcp); break; case SINGLE_STAGE: t = runTime(); if (group_present && pga->m == 0) start_group(&StartFile, auts, pga, pcp); assert(OutputFile); construct(1, &flag, SINGLE_STAGE, OutputFile, StartFile, 0, ALL, group_nmr, pga, pcp); t = runTime() - t; printf("Time for intermediate stage is %.2f seconds\n", t * CLK_SCALE); break; case DEGREE: read_step_size(pga, pcp); read_subgroup_rank(&k); query_exponent_law(pga); enforce_laws(pga, pga, pcp); extend_automorphisms(auts, pga->m, pcp); step_range(k, &pga->s, &upper_step, auts, pga, pcp); if (pga->s > upper_step) printf("Desired step size is invalid for current group\n"); else { if (pga->s < upper_step) { printf("The permitted relative step sizes range from %d to %d\n", pga->s, upper_step); read_value( TRUE, "Input the chosen relative step size: ", &pga->s, 0); } store_definition_sets(pga->r, pga->s, pga->s, pga); get_definition_sets(pga); pga->print_degree = TRUE; compute_degree(pga); pga->print_degree = FALSE; } break; case PERMUTATIONS: if (pga->Degree != 0) { t = runTime(); query_solubility(pga); pga->trace = FALSE; if (pga->soluble) query_space_efficiency(pga); else pga->space_efficient = FALSE; query_perm_information(pga); strip_identities(auts, pga, pcp); soluble_group = (pga->soluble || pga->Degree == 1 || pga->nmr_of_perms == 0); if (!soluble_group) { #if defined(GAP_LINK) StartGapFile(pga); #else #if defined(GAP_LINK_VIA_FILE) start_GAP_file(&LINK_input, auts, pga, pcp); #endif #endif } perms = permute_subgroups(LINK_input, &a, &b, &c, auts, pga, pcp); #if defined(GAP_LINK_VIA_FILE) if (!soluble_group) CloseFile(LINK_input); #endif t = runTime() - t; printf("Time to compute permutations is %.2f seconds\n", t * CLK_SCALE); } else printf("You must first select option %d\n", DEGREE); break; case ORBITS: orbit_option(option, perms, &a, &b, &c, &orbit_length, pga); break; case STABILISERS: case STABILISER: assert(perms); stabiliser_option( option, auts, perms, a, b, c, orbit_length, pga, pcp); /* free_space (pga->soluble, perms, orbit_length, a, b, c, pga); */ break; case MATRIX_TO_LABEL: S = allocate_matrix(pga->s, pga->q, 0, FALSE); subset = allocate_vector(pga->s, 0, FALSE); printf("Input the %d x %d subgroup matrix:\n", pga->s, pga->q); read_matrix(S, pga->s, pga->q); K = echelonise_matrix(S, pga->s, pga->q, pga->p, subset, pga); printf("The standard matrix is:\n"); print_matrix(S, pga->s, pga->q); printf("The label is %d\n", subgroup_to_label(S, K, subset, pga)); free_vector(subset, 0); break; case LABEL_TO_MATRIX: read_value(TRUE, "Input allowable subgroup label: ", &label, 1); S = label_to_subgroup(&index, &subset, label, pga); printf("The corresponding standard matrix is\n"); print_matrix(S, pga->s, pga->q); break; case IMAGE: t = runTime(); /* invert_automorphisms (auts, pga, pcp); print_auts (pga->m, pcp->lastg, auts, pcp); */ printf("Input the subgroup label and automorphism number: "); read_value(TRUE, "", &label, 1); read_value(FALSE, "", &alpha, 1); printf("Image is %d\n", find_image(label, auts[alpha], pga, pcp)); t = runTime() - t; printf("Computation time in seconds is %.2f\n", t * CLK_SCALE); break; case SUBGROUP_RANK: read_subgroup_rank(&k); printf("Closure of initial segment subgroup has rank %d\n", close_subgroup(k, auts, pga, pcp)); break; case ORBIT_REP: printf("Input label for subgroup: "); read_value(TRUE, "", &label, 1); rep = abs(a[label]); for (i = 1; i <= pga->nmr_orbits && pga->rep[i] != rep; ++i) ; printf("Subgroup with label %d has representative %d and is in orbit " "%d\n", label, rep, i); break; case COMPACT_DESCRIPTION: Compact_Description = TRUE; read_value(TRUE, "Lower bound for order (0 for all groups generated)? ", &Compact_Order, 0); break; case AUT_CLASSES: t = runTime(); permute_elements(); t = runTime() - t; printf("Time to compute orbits is %.2f seconds\n", t * CLK_SCALE); break; /* printf ("Input label: "); scanf ("%d", &l); process_complete_orbit (a, l, pga, pcp); break; case TEMP: printf ("Input label: "); scanf ("%d", &l); printf ("Input label: "); scanf ("%d", &u); for (i = l; i <= u; ++i) { x = IsValidAllowableSubgroup (i, pga); printf ("%d is %d\n", i, x); } StartName = GetString ("Enter output file name: "); OutputFile = OpenFileOutput (StartName); part_setup_reps (pga->rep, pga->nmr_orbits, orbit_length, perms, a, b, c, auts, OutputFile, OutputFile, pga, pcp); list_word (pga, pcp); read_value (TRUE, "Input the rank of the subgroup: ", &pga->q, 1); strip_identities (auts, pga, pcp); break; */ case EXIT: case MAX_INTERACTIVE_OPTION: printf("Exiting from interactive p-group generation menu\n"); break; } /* switch */ } while (option != 0 && option != MAX_INTERACTIVE_OPTION); #if defined(GAP_LINK) if (!soluble_group) QuitGap(); #endif }
/****************************************************************************** run_test() Run the given test case. ******************************************************************************/ void run_test(char *test) { char temp[PATH_MAX]; char *rstr; double elapsed = 0; int skip = FALSE, ignore=FALSE; int restart = FALSE; int flag = FALSE; struct stat info; // skip tests in the skip list snprintf(temp, PATH_MAX, " %s ", test); skip = (strindex(skip_test, temp) != NULL); if (skip == FALSE) ignore = (strindex(ignore_test, temp) != NULL); if (ignore) { // show test log_msg("%-46s ", test); // ignore rstr = TEST_IGNORE; ++total_ignore; } else if (!skip) // skip test? { char test_file[PATH_MAX]; char master_opt_file[PATH_MAX]; char slave_opt_file[PATH_MAX]; char slave_master_info_file[PATH_MAX]; char result_file[PATH_MAX]; char reject_file[PATH_MAX]; char out_file[PATH_MAX]; char err_file[PATH_MAX]; int err; arg_list_t al; NXTime_t start, stop; // skip slave? flag = skip_slave; skip_slave = (strncmp(test, "rpl", 3) != 0); if (flag != skip_slave) restart = TRUE; // create files snprintf(master_opt_file, PATH_MAX, "%s/%s-master.opt", test_dir, test); snprintf(slave_opt_file, PATH_MAX, "%s/%s-slave.opt", test_dir, test); snprintf(slave_master_info_file, PATH_MAX, "%s/%s.slave-mi", test_dir, test); snprintf(reject_file, PATH_MAX, "%s/%s%s", result_dir, test, REJECT_SUFFIX); snprintf(out_file, PATH_MAX, "%s/%s%s", result_dir, test, OUT_SUFFIX); snprintf(err_file, PATH_MAX, "%s/%s%s", result_dir, test, ERR_SUFFIX); // netware specific files snprintf(test_file, PATH_MAX, "%s/%s%s", test_dir, test, NW_TEST_SUFFIX); if (stat(test_file, &info)) { snprintf(test_file, PATH_MAX, "%s/%s%s", test_dir, test, TEST_SUFFIX); if (access(test_file,0)) { printf("Invalid test name %s, %s file not found\n",test,test_file); return; } } snprintf(result_file, PATH_MAX, "%s/%s%s", result_dir, test, NW_RESULT_SUFFIX); if (stat(result_file, &info)) { snprintf(result_file, PATH_MAX, "%s/%s%s", result_dir, test, RESULT_SUFFIX); } // init scripts snprintf(master_init_script, PATH_MAX, "%s/%s-master.sh", test_dir, test); if (stat(master_init_script, &info)) master_init_script[0] = NULL; else restart = TRUE; snprintf(slave_init_script, PATH_MAX, "%s/%s-slave.sh", test_dir, test); if (stat(slave_init_script, &info)) slave_init_script[0] = NULL; else restart = TRUE; // read options if (read_option(master_opt_file, master_opt)) restart = TRUE; if (read_option(slave_opt_file, slave_opt)) restart = TRUE; if (read_option(slave_master_info_file, slave_master_info)) restart = TRUE; // cleanup previous run remove(reject_file); remove(out_file); remove(err_file); // start or restart? if (!master_running) mysql_start(); else if (restart) mysql_restart(); // let the system stabalize sleep(1); // show test log_msg("%-46s ", test); // args init_args(&al); add_arg(&al, "%s", mysqltest_file); add_arg(&al, "--no-defaults"); add_arg(&al, "--port=%u", master_port); add_arg(&al, "--database=%s", db); add_arg(&al, "--user=%s", user); add_arg(&al, "--password=%s", password); add_arg(&al, "--silent"); add_arg(&al, "--basedir=%s/", mysql_test_dir); add_arg(&al, "--host=127.0.0.1"); add_arg(&al, "-v"); add_arg(&al, "-R"); add_arg(&al, "%s", result_file); if (use_openssl) { add_arg(&al, "--ssl-ca=%s", ca_cert); add_arg(&al, "--ssl-cert=%s", client_cert); add_arg(&al, "--ssl-key=%s", client_key); } // start timer NXGetTime(NX_SINCE_BOOT, NX_USECONDS, &start); // spawn err = spawn(mysqltest_file, &al, TRUE, test_file, out_file, err_file); // stop timer NXGetTime(NX_SINCE_BOOT, NX_USECONDS, &stop); // calculate elapsed = ((double)(stop - start)) / NX_USECONDS; total_time += elapsed; // free args free_args(&al); if (err == 0) { // pass rstr = TEST_PASS; ++total_pass; // increment total ++total_test; } else if (err == 62) { // skip rstr = TEST_SKIP; ++total_skip; } else if (err == 1) { // fail rstr = TEST_FAIL; ++total_fail; // increment total ++total_test; } else { rstr = TEST_BAD; } } else // early skips { // show test log_msg("%-46s ", test); // skip rstr = TEST_SKIP; ++total_skip; } // result log_msg("%10.06f %-14s\n", elapsed, rstr); }
static void parse_options(char *options) { char *tmp; int (*read_option)(char *, char *); char opt_name[MAX_PATH_LEN]; char opt_val[MAX_PATH_LEN]; int i; if (options == NULL) return; if ((opt_cmp(options, OPT_HELP)) == 0) { jcov_usage(); } cur_opt = options; read_option = read_option_cmdline; while (1) { if (read_option(opt_name, opt_val) == 0) { jcov_close(&opt_file); if (read_option == read_option_disk) read_option = read_option_cmdline; else break; } else if (opt_cmp(opt_name, OPT_OPTIONS_FILE) == 0) { if ((opt_file = fopen(opt_val, "rb")) == NULL) { sprintf(opt_name,"cannot open file : %s\n", opt_val); jcov_error_stop(opt_name); } read_option = read_option_disk; } else if (opt_cmp(opt_name, OPT_FILE) == 0) { jcov_file = (char*)jcov_calloc(strlen(opt_val) + 1); strcpy(jcov_file, opt_val); } else if (opt_cmp(opt_name, OPT_TYPE) == 0) { jcov_data_type = opt_val[0]; if (jcov_data_type == 'M' || jcov_data_type == 'm') jcov_data_type = JCOV_DATA_M; else if (jcov_data_type == 'B' || jcov_data_type == 'b') jcov_data_type = JCOV_DATA_B; else { printf("Invalid data type : %c\n", jcov_data_type); jcov_usage(); } } else if (opt_cmp(opt_name, OPT_ABSTR_METH) == 0) { if (opt_cmp(opt_val, OPT_ON) == 0) include_abstracts = 1; } else if (opt_cmp(opt_name, OPT_OVERWRITE) == 0) { if (opt_cmp(opt_val, OPT_ON) == 0) overwrite_jcov_file = 1; } else if (opt_cmp(opt_name, OPT_EC) == 0) { if (opt_cmp(opt_val, OPT_ON) == 0) load_early_classes = 1; } else if (opt_cmp(opt_name, OPT_VERBOSITY) == 0) { if (strlen(opt_val) > 1) { jcov_usage(); } i = opt_val[0] - '0'; if (i < 0 || i > 9) { jcov_usage(); } verbose_mode = i; } else if (opt_cmp(opt_name, OPT_INCLUDE) == 0) { ADD_FILTER(class_filter, incl); } else if (opt_cmp(opt_name, OPT_EXCLUDE) == 0) { ADD_FILTER(class_filter, excl); } else if (opt_cmp(opt_name, OPT_CALLER_INCL) == 0) { ADD_FILTER(caller_filter, incl); } else if (opt_cmp(opt_name, OPT_CALLER_EXCL) == 0) { ADD_FILTER(caller_filter, excl); } else { printf("Unrecognized option : %s\n", opt_name); jcov_usage(); } } }