static void query_harts(const char* config_string)
{
for (int core = 0, hart; ; core++) {
for (hart = 0; ; hart++) {
char buf[32];
snprintf(buf, sizeof buf, "core{%d{%d{ipi", core, hart);
query_result res = query_config_string(config_string, buf);
if (!res.start)
break;
hls_t* hls = hls_init(num_harts);
hls->ipi = (void*)(uintptr_t)get_uint(res);
snprintf(buf, sizeof buf, "core{%d{%d{timecmp", core, hart);
res = query_config_string(config_string, buf);
assert(res.start);
hls->timecmp = (void*)(uintptr_t)get_uint(res);
num_harts++;
}
if (!hart)
break;
}
assert(num_harts);
assert(num_harts <= MAX_HARTS);
}
/*
* Xboard - level command
* Arguments are three numbers, or four numbers with a colon between
* the two in the middle:
*
* level 40 5 0
*
* or
*
* level 20 1:40 2
*/
static void
cmd_level(void)
{
unsigned mps, base, inc;
char *base_str;
char *base_token;
char *lasts;
long long base_minutes;
long long base_seconds;
mps = get_uint(0, 1024);
base_str = get_str_arg();
inc = get_uint(0, 1024);
base_token = xstrtok_r(base_str, ":", &lasts);
base_minutes = get_num_arg(base_token);
if (base_minutes < 0 || base_minutes > 8192)
param_error();
if ((base_token = xstrtok_r(NULL, ":", &lasts)) != NULL)
base_seconds = get_num_arg(base_token);
else
base_seconds = 0;
if (base_minutes < 0 || base_minutes > 59)
param_error();
if (xstrtok_r(NULL, ":", &lasts) != NULL)
param_error();
base = ((unsigned)base_minutes) * 60 + (unsigned)base_seconds;
set_moves_left_in_time(mps);
set_computer_clock(base * 100);
set_time_inc(inc * 100);
}
static int get_fc(char **sptr, unsigned int *frameptr, double fps)
{
char *s = *sptr;
unsigned int frame, temp;
int is_time = 0;
if (!get_uint(&s, &frame))
return 0;
if (*s == ':') {
is_time = 1;
s++;
if (!get_uint(&s, &temp))
return 0;
frame = frame*60 + temp;
if (*s == ':') {
s++;
if (!get_uint(&s, &temp))
return 0;
frame = frame*60 + temp;
}
}
if (*s == '.' || is_time) {
frame = (unsigned int)floor(frame * fps);
}
if (*s == '.') {
s++;
if (!get_uint(&s, &temp))
return 0;
frame += temp;
}
*sptr = s;
*frameptr = frame;
return 1;
}
static foreign_t
pl_tipc_subscribe(term_t Socket, term_t Address,
term_t timeout, term_t filter, term_t usr_handle)
{ struct sockaddr_tipc sockaddr;
struct tipc_subscr subscr;
int socket;
unsigned time, filt;
char *handle;
size_t handle_len;
SOCKET fd;
memset(&subscr, 0, sizeof(subscr));
memset(&sockaddr, 0, sizeof(sockaddr));
if ( !tipc_get_socket(Socket, &socket) ||
!nbio_get_tipc_sockaddr(Address, &sockaddr))
return FALSE;
if(sockaddr.addrtype != TIPC_ADDR_NAMESEQ)
return pl_error(NULL, 0, NULL, ERR_DOMAIN, Address, "name_seq/3");
if( !get_uint(timeout, &time))
return pl_error(NULL, 0, NULL, ERR_DOMAIN, timeout, "integer");
if( !get_uint(filter, &filt))
return pl_error(NULL, 0, NULL, ERR_DOMAIN, filter, "integer");
if ( !PL_get_nchars(usr_handle, &handle_len, &handle, CVT_ALL|CVT_EXCEPTION) )
return FALSE;
if(tipc_version > 1)
{ struct tipc_name_seq *p = &subscr.seq,
*p1 = &sockaddr.addr.nameseq;
p->type = htonl(p1->type);
p->lower = htonl(p1->lower);
p->upper = htonl(p1->upper);
subscr.timeout = htonl(time);
subscr.filter = htonl((filt == V1_TIPC_SUB_SERVICE)
? TIPC_SUB_SERVICE
: filt);
} else {
memcpy(&subscr.seq, &sockaddr.addr.nameseq, sizeof(subscr.seq));
subscr.timeout = time;
subscr.filter = filt;
}
memcpy(&subscr.usr_handle, handle,
(handle_len < sizeof(subscr.usr_handle))
? handle_len
: sizeof(subscr.usr_handle));
fd = nbio_fd(socket);
if ( (send(fd, &subscr, sizeof(subscr), 0)) != sizeof(subscr) )
return nbio_error(errno, TCP_ERRNO);
else
return TRUE;
}
static void query_mem(const char* config_string)
{
query_result res = query_config_string(config_string, "ram{0{addr");
assert(res.start);
mem_base = get_uint(res);
res = query_config_string(config_string, "ram{0{size");
mem_size = get_uint(res);
}
static void query_plic(const char* config_string)
{
query_result res = query_config_string(config_string, "plic{priority");
if (!res.start)
return;
plic_priorities = (uint32_t*)(uintptr_t)get_uint(res);
res = query_config_string(config_string, "plic{ndevs");
if (!res.start)
return;
plic_ndevs = get_uint(res);
}
static t_stat get_ipaddr (char *cptr, uint32 *ipa, uint32 *ipp)
{
char gbuf[CBUFSIZE];
char *addrp, *portp, *octetp;
uint32 i, addr, port, octet;
t_stat r;
if ((cptr == NULL) || (*cptr == 0))
return SCPE_ARG;
strncpy (gbuf, cptr, CBUFSIZE);
addrp = gbuf; /* default addr */
if ((portp = strchr (gbuf, ':'))) /* x:y? split */
*portp++ = 0;
else if (strchr (gbuf, '.')) /* x.y...? */
portp = NULL;
else {
portp = gbuf; /* port only */
addrp = NULL; /* no addr */
}
if (portp) { /* port string? */
if (ipp == NULL) /* not wanted? */
return SCPE_ARG;
port = (int32) get_uint (portp, 10, 65535, &r);
if ((r != SCPE_OK) || (port == 0))
return SCPE_ARG;
}
else port = 0;
if (addrp) { /* addr string? */
if (ipa == NULL) /* not wanted? */
return SCPE_ARG;
for (i = addr = 0; i < 4; i++) { /* four octets */
octetp = strchr (addrp, '.'); /* find octet end */
if (octetp != NULL) /* split string */
*octetp++ = 0;
else if (i < 3) /* except last */
return SCPE_ARG;
octet = (int32) get_uint (addrp, 10, 255, &r);
if (r != SCPE_OK)
return SCPE_ARG;
addr = (addr << 8) | octet;
addrp = octetp;
}
if (((addr & 0377) == 0) || ((addr & 0377) == 255))
return SCPE_ARG;
}
else addr = 0;
if (ipp) /* return req values */
*ipp = port;
if (ipa)
*ipa = addr;
return SCPE_OK;
}
void parseCommand (char * cmdstr)
{
int8_t cmd=-1;
int16_t num=0;
// Serial.print("parseCommand:"); Serial.println(cmdstr);
char * actpos = strtok(cmdstr," "); // see a nice explaination of strtok here: http://www.reddit.com/r/arduino/comments/2h9l1l/using_the_strtok_function/
if (actpos)
{
strup(actpos);
// housekeeping commands
if (!strcmp(actpos,"ID")) cmd=CMD_PRINT_ID;
if (!strcmp(actpos,"SAVE")) { actpos=strtok(NULL," "); cmd=CMD_SAVE_SLOT; }
if (!strcmp(actpos,"LOAD")) { actpos=strtok(NULL," "); cmd=CMD_LOAD_SLOT; }
if (!strcmp(actpos,"NEXT")) cmd=CMD_NEXT_SLOT;
if (!strcmp(actpos,"CLEAR")) cmd=CMD_DELETE_SLOTS;
if (!strcmp(actpos,"LIST")) cmd=CMD_LIST_SLOTS;
if (!strcmp(actpos,"IDLE")) cmd=CMD_IDLE;
// button feature commands
if (!strcmp(actpos,"BM")) { actpos=strtok(NULL," "); if (get_uint(actpos, &num)) cmd=CMD_BUTTON_MODE; }
if (!strcmp(actpos,"CL")) cmd=CMD_MOUSE_CLICK_LEFT;
if (!strcmp(actpos,"CR")) cmd=CMD_MOUSE_CLICK_RIGHT;
if (!strcmp(actpos,"CM")) cmd=CMD_MOUSE_CLICK_MIDDLE;
if (!strcmp(actpos,"CD")) cmd=CMD_MOUSE_CLICK_DOUBLE;
if (!strcmp(actpos,"PL")) cmd=CMD_MOUSE_PRESS_LEFT;
if (!strcmp(actpos,"PR")) cmd=CMD_MOUSE_PRESS_RIGHT;
if (!strcmp(actpos,"PM")) cmd=CMD_MOUSE_PRESS_MIDDLE;
if (!strcmp(actpos,"RL")) cmd=CMD_MOUSE_RELEASE_LEFT;
if (!strcmp(actpos,"RR")) cmd=CMD_MOUSE_RELEASE_RIGHT;
if (!strcmp(actpos,"RM")) cmd=CMD_MOUSE_RELEASE_MIDDLE;
if (!strcmp(actpos,"WU")) cmd=CMD_MOUSE_WHEEL_UP;
if (!strcmp(actpos,"WD")) cmd=CMD_MOUSE_WHEEL_DOWN;
if (!strcmp(actpos,"WS")) { actpos=strtok(NULL," "); if (get_uint(actpos, &num)) cmd=CMD_MOUSE_WHEEL_STEP; }
if (!strcmp(actpos,"MX")) { actpos=strtok(NULL," "); if (get_int(actpos, &num)) cmd=CMD_MOUSE_MOVEX; }
if (!strcmp(actpos,"MY")) { actpos=strtok(NULL," "); if (get_int(actpos, &num)) cmd=CMD_MOUSE_MOVEY; }
if (!strcmp(actpos,"KW")) { actpos+=3; cmd=CMD_KEY_WRITE; }
if (!strcmp(actpos,"KP")) { actpos+=3; cmd=CMD_KEY_PRESS; }
if (!strcmp(actpos,"KR")) { actpos+=3; cmd=CMD_KEY_RELEASE; }
if (!strcmp(actpos,"RA")) cmd=CMD_RELEASE_ALL;
}
if (cmd>-1)
{
// Serial.print("cmd parser found:");Serial.print(cmd); Serial.print(", "); Serial.print(num);
// if (actpos) {Serial.print(", "); Serial.println(actpos);} else Serial.println();
performCommand(cmd,num,actpos,0);
}
else Serial.println("cmd parser: ?");
}
t_stat vax780_fload (int32 flag, char *cptr)
{
char gbuf[CBUFSIZE];
uint16 file_name[3], blkbuf[BLK_SIZE];
t_stat r;
uint32 i, j, start, size, origin;
if ((fl_unit.flags & UNIT_ATT) == 0) /* floppy attached? */
return SCPE_UNATT;
if (*cptr == 0)
return SCPE_2FARG;
cptr = get_glyph (cptr, gbuf, 0); /* get file name */
if (!rtfile_parse (gbuf, file_name)) /* legal file name? */
return SCPE_ARG;
if ((size = rtfile_lookup (file_name, &start)) == 0) /* file on floppy? */
return SCPE_ARG;
if (*cptr) { /* origin? */
origin = (uint32) get_uint (cptr, 16, MEMSIZE, &r);
if ((r != SCPE_OK) || (origin & 1)) /* must be even */
return SCPE_ARG;
}
else origin = 512; /* no, use default */
for (i = 0; i < size; i++) { /* loop thru blocks */
if (!rtfile_read (start + i, 1, blkbuf)) /* read block */
return SCPE_FMT;
for (j = 0; j < BLK_SIZE; j++) { /* loop thru words */
if (ADDR_IS_MEM (origin))
WriteW (origin, blkbuf[j]);
else return SCPE_NXM;
origin = origin + 2;
}
}
return SCPE_OK;
}
static int
map_str2int(struct state *cur, const char *value,
unsigned int *vp, struct map *map)
{
unsigned int n;
const char *what;
if (isdigit((int) *value))
return get_uint(cur, value, vp);
for (n = 0; map[n].name; n++) {
if (!strcasecmp(value, map[n].name)) {
*vp = map[n].val;
return 0;
}
}
/* Try to print a meaningful error message */
what = "argument";
for (n = 0; mapNames[n].name; n++) {
if (mapNames[n].addr == map) {
what = mapNames[n].name;
break;
}
}
parse_error(cur, "invalid %s \"%s\"\n", what, value);
return SC_ERROR_SYNTAX_ERROR;
}
t_stat mux_vlines (UNIT *uptr, int32 val, char *cptr, void *desc)
{
int32 newln, i, t;
t_stat r;
if (cptr == NULL)
return SCPE_ARG;
newln = get_uint (cptr, 10, MUX_LINES, &r);
if ((r != SCPE_OK) || (newln == MUX_NUMLIN))
return r;
if (newln == 0) return SCPE_ARG;
if (newln < MUX_NUMLIN) {
for (i = newln, t = 0; i < MUX_NUMLIN; i++) t = t | mux_ldsc[i].conn;
if (t && !get_yn ("This will disconnect users; proceed [N]?", FALSE))
return SCPE_OK;
for (i = newln; i < MUX_NUMLIN; i++) {
if (mux_ldsc[i].conn) {
tmxr_linemsg (&mux_ldsc[i], "\r\nOperator disconnected line\r\n");
tmxr_reset_ln (&mux_ldsc[i]); /* reset line */
}
muxl_unit[i].flags = muxl_unit[i].flags | UNIT_DIS;
mux_reset_ln (i);
}
}
else {
for (i = MUX_NUMLIN; i < newln; i++) {
muxl_unit[i].flags = muxl_unit[i].flags & ~UNIT_DIS;
mux_reset_ln (i);
}
}
MUX_NUMLIN = newln;
return SCPE_OK;
}
t_stat rtc_set_tps (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
uint32 newval, i;
t_stat r;
if (val >= RTC_NUM_EVNTS) /* validate params */
return SCPE_IERR;
if (cptr == NULL) /* must have arg */
return SCPE_ARG;
newval = get_uint (cptr, 10, 10000, &r);
if ((r != SCPE_OK) || /* error? */
((newval == 0) && (val >= 2))) /* can't turn off 3,4 */
return SCPE_ARG;
for (i = 0; i < RTC_NUM_HZ; i++) { /* loop thru freqs */
if (newval == rtc_tab[i].hz) { /* found freq? */
if (val < RTC_NUM_CNTRS) /* for clocks */
rtc_tps[val] = i; /* save val for reset */
rtc_indx[val] = i; /* save event vals */
rtc_cntr[val] = rtc_tab[i].cntr_reset;
rtc_xtra[val] = rtc_tab[i].xtra_reset;
return SCPE_OK;
}
}
return SCPE_ARG;
}
t_stat dtc_setnl (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
int32 newln, i, t;
t_stat r;
if (cptr == NULL)
return SCPE_ARG;
newln = (int32) get_uint (cptr, 10, DTC_MLINES, &r);
if ((r != SCPE_OK) || (newln == dtc_desc.lines))
return r;
if ((newln == 0) || (newln > DTC_MLINES))
return SCPE_ARG;
if (newln < dtc_desc.lines) {
for (i = newln-1, t = 0; i < dtc_desc.lines; i++)
t = t | dtc_ldsc[i].conn;
if (t && !get_yn ("This will disconnect users; proceed [N]?", FALSE))
return SCPE_OK;
for (i = newln-1; i < dtc_desc.lines; i++) {
if (dtc_ldsc[i].conn) {
tmxr_linemsg (&dtc_ldsc[i], "\r\nOperator disconnected line\r\n");
tmxr_send_buffered_data (&dtc_ldsc[i]);
}
tmxr_detach_ln (&dtc_ldsc[i]); /* completely reset line */
}
}
if (dtc_desc.lines < newln)
memset (dtc_ldsc + dtc_desc.lines, 0, sizeof(*dtc_ldsc)*(newln-dtc_desc.lines));
dtc_desc.lines = newln;
return dtc_reset (&dtc_dev); /* setup lines and auto config */
}
/*
* Common routine to change the equipment address of a peripheral. Some
* devices (e.g. TT, PTR etc) cannot have their equipment address changed.
*/
t_stat set_equipment(UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
DEVICE *dptr;
IO_DEVICE *iod;
t_value v;
t_stat r;
if (cptr == NULL)
return SCPE_ARG;
v = get_uint(cptr, DEV_RDX, 15, &r);
if (r != SCPE_OK)
return r;
if (v == 0)
return SCPE_ARG;
/*
* Check to see if any other, non-disabled device is already using this
* address.
*/
if ((dptr = find_dev_from_unit(uptr)) != NULL) {
if (checkDuplicate(dptr, v))
return sim_messagef(SCPE_ARG, "Equipment address already in use\n");
iod = (IO_DEVICE *)dptr->ctxt;
iod->iod_equip = v;
iod->iod_interrupt = 1 << v;
return SCPE_OK;
}
return SCPE_NXDEV;
}
t_stat set_iobase(UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
DEVICE* dptr;
PNP_INFO* pnp;
t_stat rc;
uint16 newbase;
if (!cptr) return SCPE_ARG;
if (!uptr) return SCPE_IERR;
if (!(dptr = find_dev_from_unit(uptr))) return SCPE_IERR;
if (!(pnp = (PNP_INFO*)dptr->ctxt)) return SCPE_IERR;
newbase = get_uint (cptr, 16, 0xFF, &rc);
if (rc != SCPE_OK) return rc;
if (dptr->flags & DEV_DIS) {
printf("Device not enabled yet.\n");
pnp->io_base = newbase;
} else {
dptr->flags |= DEV_DIS;
dptr->reset(dptr);
pnp->io_base = newbase;
dptr->flags &= ~DEV_DIS;
dptr->reset(dptr);
}
return SCPE_OK;
}
t_stat sim_load (FILE *fileref, char *cptr, char *fnam, int flag)
{
t_stat r;
int32 val;
uint32 origin, limit;
if (flag) /* dump? */
return SCPE_ARG;
origin = 0; /* memory */
limit = (uint32) cpu_unit.capac;
if (sim_switches & SWMASK ('O')) { /* origin? */
origin = (int32) get_uint (cptr, 16, 0xFFFFFFFF, &r);
if (r != SCPE_OK)
return SCPE_ARG;
}
while ((val = getc (fileref)) != EOF) { /* read byte stream */
if (sim_switches & SWMASK ('R')) { /* ROM0? */
return SCPE_NXM;
}
else if (sim_switches & SWMASK ('S')) { /* ROM1? */
return SCPE_NXM;
}
else {
if (origin >= limit) /* NXM? */
return SCPE_NXM;
WriteB (origin, val); /* memory */
}
origin = origin + 1;
}
return SCPE_OK;
}
const char *
parse_setting_from_defs(pool_t pool, const struct setting_def *defs, void *base,
const char *key, const char *value)
{
const struct setting_def *def;
for (def = defs; def->name != NULL; def++) {
if (strcmp(def->name, key) == 0) {
void *ptr = STRUCT_MEMBER_P(base, def->offset);
switch (def->type) {
case SET_STR:
*((char **)ptr) = p_strdup(pool, value);
return NULL;
case SET_INT:
/* use %i so we can handle eg. 0600
as octal value with umasks */
return get_uint(value, (unsigned int *) ptr);
case SET_BOOL:
return get_bool(value, (bool *) ptr);
}
}
}
return t_strconcat("Unknown setting: ", key, NULL);
}
static int _set_rec(int *start, int argc, char *argv[],
slurmdb_job_rec_t *job)
{
int i;
int set = 0;
int end = 0;
int command_len = 0;
for (i=(*start); i<argc; i++) {
end = parse_option_end(argv[i]);
if (!end)
command_len=strlen(argv[i]);
else {
command_len=end-1;
if (argv[i][end] == '=') {
end++;
}
}
if (!strncasecmp (argv[i], "Where", MAX(command_len, 5))) {
i--;
break;
} else if (!end && !strncasecmp(argv[i], "set",
MAX(command_len, 3))) {
continue;
} else if (!end) {
exit_code=1;
fprintf(stderr,
" Bad format on %s: End your option with "
"an '=' sign\n", argv[i]);
} else if ((!strncasecmp(argv[i], "DerivedExitCode",
MAX(command_len, 12))) ||
(!strncasecmp(argv[i], "DerivedEC",
MAX(command_len, 9)))) {
if (get_uint(argv[i]+end, &job->derived_ec,
"DerivedExitCode") == SLURM_SUCCESS) {
set = 1;
}
} else if ((!strncasecmp(argv[i], "Comment",
MAX(command_len, 7))) ||
(!strncasecmp(argv[i], "DerivedExitString",
MAX(command_len, 12))) ||
(!strncasecmp(argv[i], "DerivedES",
MAX(command_len, 9)))) {
if (job->derived_es)
xfree(job->derived_es);
job->derived_es = strip_quotes(argv[i]+end, NULL, 1);
set = 1;
} else {
printf(" Unknown option: %s\n"
" Use keyword 'where' to modify condition\n",
argv[i]);
}
}
(*start) = i;
return set;
}
static int
get_user(char **tokptr, sys_data_t *sys, const char **err)
{
unsigned int num;
unsigned int val;
int rv;
rv = get_uint(tokptr, &num, err);
if (rv)
return rv;
if (num > MAX_USERS) {
*err = "User number larger than the allowed number of users";
return -1;
}
rv = get_bool(tokptr, &val, err);
if (rv)
return rv;
sys->cusers[num].valid = val;
rv = read_bytes(tokptr, sys->cusers[num].username, err, 16);
if (rv)
return rv;
rv = read_bytes(tokptr, sys->cusers[num].pw, err, 20);
if (rv)
return rv;
rv = get_priv(tokptr, &val, err);
if (rv)
return rv;
sys->cusers[num].privilege = val;
rv = get_uint(tokptr, &val, err);
if (rv)
return rv;
sys->cusers[num].max_sessions = val;
rv = get_auths(tokptr, &val, err);
if (rv)
return rv;
sys->cusers[num].allowed_auths = val;
return 0;
}
int flag_u(t_string *string, int i)
{
if (!ft_strncmp(string->converter.type, "ll", 2))
conv_ll(string, get_ulong_long_int(string));
else if (!ft_strncmp(string->converter.type, "l", 1))
conv_l(string, get_ulong_int(string));
else if (!ft_strncmp(string->converter.type, "hh", 2))
conv_hh(string, (unsigned char)get_uint(string));
else if (!ft_strncmp(string->converter.type, "h", 1))
conv_h(string, get_ushort(string));
else if (!ft_strncmp(string->converter.type, "z", 1))
conv_z(string, get_size_t(string));
else if (!ft_strncmp(string->converter.type, "j", 1))
conv_j(string, get_intmax_t(string));
else
conv_default(string, get_uint(string));
return (i + 1);
}
uint8_t get_int(char * str, int * result)
{
int num,fact;
if (str==0) return(0);
if (*str =='-') {fact=-1; str++;} else fact=1;
if (!get_uint(str,&num)) return(0);
*result=num*fact;
return(1);
}
/*
* Set the number of lines for the PORTS mux. This will add or remove
* cards as necessary. The number of lines must be a multiple of 4.
*/
t_stat ports_setnl(UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
int32 newln, i, t;
t_stat r = SCPE_OK;
if (cptr == NULL) {
return SCPE_ARG;
}
newln = (int32) get_uint(cptr, 10, (MAX_PORTS_CARDS * PORTS_LINES), &r);
if ((r != SCPE_OK) || (newln == ports_desc.lines)) {
return r;
}
if ((newln == 0) || LPORT(newln) != 0) {
return SCPE_ARG;
}
if (newln < ports_desc.lines) {
for (i = newln, t = 0; i < ports_desc.lines; i++) {
t = t | ports_ldsc[i].conn;
}
if (t && !get_yn("This will disconnect users; proceed [N]?", FALSE)) {
return SCPE_OK;
}
for (i = newln; i < ports_desc.lines; i++) {
if (ports_ldsc[i].conn) {
tmxr_linemsg(&ports_ldsc[i], "\r\nOperator disconnected line\r\n");
tmxr_send_buffered_data(&ports_ldsc[i]);
}
/* completely reset line */
tmxr_detach_ln(&ports_ldsc[i]);
if (LPORT(i) == (PORTS_LINES - 1)) {
/* Also drop the corresponding card from the CIO array */
cio_clear(LCID(i));
}
}
}
ports_desc.ldsc = ports_ldsc = (TMLN *)realloc(ports_ldsc, newln*sizeof(*ports_ldsc));
ports_state = (PORTS_LINE_STATE *)realloc(ports_state, newln*sizeof(*ports_state));
if (ports_desc.lines < newln) {
memset(ports_ldsc + ports_desc.lines, 0, sizeof(*ports_ldsc)*(newln-ports_desc.lines));
memset(ports_state + ports_desc.lines, 0, sizeof(*ports_state)*(newln-ports_desc.lines));
}
ports_desc.lines = newln;
/* setup lines and auto config */
ports_conf = FALSE;
return ports_reset(&ports_dev);
}
static int
do_reclength(struct state *cur, int argc, char **argv)
{
unsigned int reclength;
if (get_uint(cur, argv[0], &reclength))
return 1;
cur->file->file->record_length = reclength;
return 0;
}
static int
do_pin_storedlength(struct state *cur, int argc, char **argv)
{
unsigned int len;
if (get_uint(cur, argv[0], &len))
return 1;
cur->pin->pin.stored_length = len;
return 0;
}
static int
do_pin_reference(struct state *cur, int argc, char **argv)
{
unsigned int reference;
if (get_uint(cur, argv[0], &reference))
return 1;
cur->pin->pin.reference = reference;
return 0;
}
t_stat lp_load_cct (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
uint32 col, rpt, ptr, mask;
uint8 cctbuf[CCT_LNT];
t_stat r;
char cbuf[CBUFSIZE], gbuf[CBUFSIZE];
FILE *cfile;
if ((cptr == NULL) || (*cptr == 0)) return SCPE_ARG;
if ((cfile = fopen (cptr, "r")) == NULL)
return SCPE_OPENERR;
ptr = 0;
for ( ; (cptr = fgets (cbuf, CBUFSIZE, cfile)) != NULL; ) {
mask = 0;
if (*cptr == '(') { /* repeat count? */
cptr = get_glyph (cptr + 1, gbuf, ')'); /* get 1st field */
rpt = get_uint (gbuf, 10, CCT_LNT, &r); /* repeat count */
if (r != SCPE_OK)
return SCPE_FMT;
}
else rpt = 1;
while (*cptr != 0) { /* get col no's */
cptr = get_glyph (cptr, gbuf, ','); /* get next field */
col = get_uint (gbuf, 10, FMT_MCH4, &r); /* column number */
if (r != SCPE_OK)
return SCPE_FMT;
mask = mask | (1 << col); /* set bit */
}
for ( ; rpt > 0; rpt--) { /* store vals */
if (ptr >= CCT_LNT)
return SCPE_FMT;
cctbuf[ptr++] = mask;
}
}
if (ptr == 0)
return SCPE_FMT;
lp_cctl = ptr;
lp_cctp = 0;
for (rpt = 0; rpt < lp_cctl; rpt++)
lp_cct[rpt] = cctbuf[rpt];
fclose (cfile);
return SCPE_OK;
}
void start_circles()
{
std::string repeat;
do
{
UserInput in;
user_input("Enter xc: ", "xc", in);
user_input("Enter yc: ", "yc", in);
user_input("Enter R: ", "R", in);
user_input("Enter color (hex): ", "color", in);
user_input("Enter pixel size: ", "scale", in);
user_input("Enter delay animation: ", "delay", in);
user_input("Exter simple circle or michener circle (s/m): ",
"circle", in);
if (in["circle"] == "s")
{
simple_circle(get_int("xc", in),
get_int("yc", in),
get_int("R", in),
get_uint("color", in, 16),
get_int("delay", in),
get_int("scale", in)
);
}
if (in["circle"] == "m")
{
michener_circle(get_int("xc", in),
get_int("yc", in),
get_int("R", in),
get_uint("color", in, 16),
get_int("delay", in),
get_int("scale", in)
);
}
user_input("What more (y/n): ", "repeat", in);
repeat = in["repeat"];
}
while(repeat == "y");
}
static void
cmd_perfts(void)
{
unsigned depth;
depth = get_uint(1, 1024);
for (unsigned i = 1; i <= depth; ++i) {
uintmax_t n = perft(current_position(), i);
printf("%s%u : %" PRIuMAX "\n", (i < 10) ? " " : "", i, n);
}
}
static int
do_pin_attempts(struct state *cur, int argc, char **argv)
{
struct pin_info *pi = cur->pin;
unsigned int count;
if (get_uint(cur, argv[0], &count))
return 1;
pi->pin.tries_left = count;
return 0;
}
t_stat dp_setformat (UNIT *uptr, int32 val, char *cptr, void *desc)
{
uint32 h, c, cntr, rptr;
int32 i, nr, nw, inp;
uint16 tbuf[DP_TRKLEN];
float finp;
t_stat r;
if (uptr == NULL)
return SCPE_IERR;
if (cptr == NULL)
return SCPE_ARG;
if (!(uptr->flags & UNIT_ATT))
return SCPE_UNATT;
inp = (int32) get_uint (cptr, 10, 2048, &r);
if (r != SCPE_OK)
return r;
if (inp == 0)
return SCPE_ARG;
finp = (float) inp;
if (sim_switches & SWMASK ('R')) { /* format records? */
nr = inp;
nw = (int32) ((dp_tab[dp_ctype].wrds / (finp + ((finp - 1.0) / 20.0))) - REC_OVHD_WRDS);
if (nw <= 0)
return SCPE_ARG;
}
else {
nw = inp; /* format words */
nr = (int32) ((((20.0 * dp_tab[dp_ctype].wrds) / (finp + REC_OVHD_WRDS)) + 1.0) / 21.0);
if (nr <= 0)
return SCPE_ARG;
}
printf ("Proposed format: records/track = %d, record size = %d\n", nr, nw);
if (!get_yn ("Formatting will destroy all data on this disk; proceed? [N]", FALSE))
return SCPE_OK;
for (c = cntr = 0; c < dp_tab[dp_ctype].cyl; c++) {
for (h = 0; h < dp_tab[dp_ctype].surf; h++) {
for (i = 0; i < DP_TRKLEN; i++)
tbuf[i] = 0;
rptr = 0;
for (i = 0; i < nr; i++) {
tbuf[rptr + REC_LNT] = nw & DMASK;
if (sim_switches & SWMASK ('S'))
tbuf[rptr + REC_ADDR] = cntr++;
else tbuf[rptr + REC_ADDR] = (c << 8) + (h << 3) + i;
rptr = rptr + nw + REC_OVHD;
}
if (r = dp_wrtrk (uptr, tbuf, c, h))
return r;
}
}
printf ("Formatting complete\n");
return SCPE_OK;
}
