/* PUBLIC */
int natural_constant_term(Term t)
{
if (!CONSTANT(t))
return -1;
else
return natural_string(sn_to_str(SYMNUM(t)));
} /* natural_constant_term */
/* PUBLIC */
BOOL term_to_double(Term t, double *result)
{
if (CONSTANT(t))
return str_to_double(sn_to_str(SYMNUM(t)), result);
else
return FALSE;
} /* term_to_double */
static
Term trm_set_vars_recurse(Term t, char **varnames, int max_vars)
{
if (CONSTANT(t)) {
char *name = sn_to_str(SYMNUM(t));
if (variable_name(name)) {
int i = 0;
while (i < max_vars && varnames[i] != NULL && varnames[i] != name)
i++;
if (i == max_vars)
fatal_error("trm_set_vars_recurse: max_vars");
else {
if (varnames[i] == NULL)
varnames[i] = name;
free_term(t);
t = get_variable_term(i);
}
}
}
else {
int i;
for (i = 0; i < ARITY(t); i++)
ARG(t,i) = trm_set_vars_recurse(ARG(t,i), varnames, max_vars);
}
return t;
} /* trm_set_vars_recurse */
/* PUBLIC */
BOOL end_of_commands_term(Term t)
{
if (t == NULL)
return FALSE;
else if (!CONSTANT(t))
return FALSE;
else
return is_symbol(SYMNUM(t), "end_of_commands", 0);
} /* end_of_commands_term */
/* PUBLIC */
BOOL term_to_int(Term t, int *result)
{
if (CONSTANT(t)) {
return str_to_int(sn_to_str(SYMNUM(t)), result);
}
else if (is_term(t, "-", 1)) {
if (!CONSTANT(ARG(t,0)))
return FALSE;
else {
if (str_to_int(sn_to_str(SYMNUM(ARG(t,0))), result)) {
*result = -(*result);
return TRUE;
}
else return FALSE;
}
}
else
return FALSE;
} /* term_to_int */
void print_session_info(FILE *f, CK_SESSION_INFO *info)
{
int i;
enum_specs ck_flags[2] = {
CONSTANT(CKF_RW_SESSION),
CONSTANT(CKF_SERIAL_SESSION)
};
fprintf(f, "%20s: %ld\n", "Slot ID", info->slotID);
fprintf(f, "%20s: '%32.32s'\n", "State",
lookup_enum(STA_T, info->state));
fprintf(f, "%20s: %0lx\n", "Flags", info->flags);
for(i = 0; i < 2; i++) {
if(info->flags & ck_flags[i].type) {
fprintf(f, "%32s%s\n", "", ck_flags[i].name);
}
}
fprintf(f, "%20s: %0lx\n", "Device Error", info->ulDeviceError);
}
static
BOOL top_safe(Term t, int domain_size)
{
if (VARIABLE(t))
return TRUE;
else if (CONSTANT(t))
return natural_constant_term(t) < domain_size;
else if (arith_op_term(t) || arith_rel_term(t))
return FALSE;
else
return TRUE;
} /* top_safe */
static
BOOL non_arith(Term t)
{
if (VARIABLE(t))
return FALSE;
else if (CONSTANT(t))
return natural_constant_term(t) < 0;
else if (arith_rel_term(t) || arith_op_term(t))
return FALSE;
else
return TRUE;
} /* non_arith */
/* PUBLIC */
int term_depth(Term t)
{
if (VARIABLE(t) || CONSTANT(t))
return 0;
else {
int i;
int max = 0;
for (i = 0; i < ARITY(t); i++) {
int d = term_depth(ARG(t,i));
max = IMAX(max,d);
}
return max+1;
}
} /* term_depth */
/* PUBLIC */
Term subst_var_term(Term t, int symnum, int varnum)
{
if (CONSTANT(t) && SYMNUM(t) == symnum) {
Term v = get_variable_term(varnum);
zap_term(t);
return v;
}
else {
int i;
for (i = 0; i < ARITY(t); i++)
ARG(t,i) = subst_var_term(ARG(t,i), symnum, varnum);
return t;
}
} /* subst_var_term */
void print_slot_info(FILE *f, CK_SLOT_INFO *info)
{
int i;
enum_specs ck_flags[3] = {
CONSTANT(CKF_TOKEN_PRESENT),
CONSTANT(CKF_REMOVABLE_DEVICE),
CONSTANT(CKF_HW_SLOT),
};
fprintf(f, "%20s: '%32.32s'\n", "Slot Description", info->slotDescription);
fprintf(f, "%20s '%32.32s'\n", "", info->slotDescription+32);
fprintf(f, "%20s: '%32.32s'\n", "Manufacturer", info->manufacturerID);
fprintf(f, "%20s: %d.%d\n", "Hardware Version",
info->hardwareVersion.major, info->hardwareVersion.minor);
fprintf(f, "%20s: %d.%d\n", "Firmware Version",
info->firmwareVersion.major, info->firmwareVersion.minor);
fprintf(f, "%20s: %0lx\n", "Flags", info->flags);
for(i = 0; i < 3; i++) {
if(info->flags & ck_flags[i].type) {
fprintf(f, "%23s%s\n", "", ck_flags[i].name);
}
}
}
/* PUBLIC */
BOOL end_of_list_formula(Formula f)
{
if (f == NULL)
return FALSE;
else if (f->type != ATOM_FORM)
return FALSE;
else {
Term a = f->atom;
if (!CONSTANT(a))
return FALSE;
else
return is_symbol(SYMNUM(a), "end_of_list", 0);
}
} /* end_of_list_formula */
/* PUBLIC */
BOOL end_of_list_clause(Topform c)
{
if (c == NULL)
return FALSE;
else if (number_of_literals(c->literals) != 1)
return FALSE;
else {
Term a = c->literals->atom;
if (!CONSTANT(a))
return FALSE;
else
return is_symbol(SYMNUM(a), "end_of_list", 0);
}
} /* end_of_list_clause */
END_TEST
START_TEST (check_credential_address_s) {
stringer_t *cred;
char *errmsg = NULL;
log_unit("%-64.64s", "OBJECTS / USERS / CERDENTIALS / ADDRESS / SINGLE THREADED:");
if (!errmsg && (!(cred = credential_address(CONSTANT("*****@*****.**"))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [1].";
//printf("r1 = %lx\n", (unsigned long) cred); if (cred) printf("xxx: [%.*s] [%u]\n", (int)st_length_get(cred), st_char_get(cred), (int)st_length_get(cred));
}
st_cleanup(cred);
cred = NULL;
if (!errmsg && (!(cred = credential_address(CONSTANT(" TEST @ DOMAIN.COM "))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [2].";
//printf("r2 = %lx\n", (unsigned long) cred); if (cred) printf("xxx: [%.*s] [%u]\n", (int)st_length_get(cred), st_char_get(cred), (int)st_length_get(cred));
}
st_cleanup(cred);
cred = NULL;
if (!errmsg && (!(cred = credential_address(CONSTANT("*****@*****.**"))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [5].";
}
st_cleanup(cred);
cred = NULL;
if (!errmsg && (!(cred = credential_address(CONSTANT("*****@*****.**"))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [2].";
//printf("rx2 = %lx\n", (unsigned long) cred); if (cred) printf("xxx: [%.*s] [%u]\n", (int)st_length_get(cred), st_char_get(cred), (int)st_length_get(cred));
}
st_cleanup(cred);
cred = NULL;
if (!errmsg && (!(cred = credential_address(CONSTANT(" TEST @ DOMAIN.COM "))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [5].";
}
st_cleanup(cred);
cred = NULL;
if (!errmsg && (!(cred = credential_address(CONSTANT("*****@*****.**"))) || st_cmp_ci_eq(cred, CONSTANT("*****@*****.**")))) {
errmsg = "Address boiler failed [11].";
}
st_cleanup(cred);
cred = NULL;
log_unit("%10.10s\n", (!status() ? "SKIPPED" : !errmsg ? "PASSED" : "FAILED"));
fail_unless(!errmsg, errmsg);
} END_TEST
static
int compare_ncv_context(Term t1, Term t2,
Context c1, Context c2)
{
int rc, m1, m2;
if (CONSTANT(t1) && !CONSTANT(t2))
rc = LESS_THAN;
else if (!CONSTANT(t1) && CONSTANT(t2))
rc = GREATER_THAN;
else if (COMPLEX(t1) && VARIABLE(t2))
rc = LESS_THAN;
else if (VARIABLE(t1) && COMPLEX(t2))
rc = GREATER_THAN;
/* Now we know they are the same type. */
else if VARIABLE(t1) {
/* both variables */
m1 = (c1 ? c1->multiplier : INT_MIN);
m2 = (c2 ? c2->multiplier : INT_MIN);
if (m1 < m2)
rc = LESS_THAN;
else if (m1 > m2)
rc = GREATER_THAN;
else if (VARNUM(t1) < VARNUM(t2))
rc = LESS_THAN;
else if (VARNUM(t1) > VARNUM(t2))
rc = GREATER_THAN;
else
rc = SAME_AS;
}
else {
if (SYMNUM(t1) < SYMNUM(t2))
static
BOOL all_ordinary_nodes_safe(Term t, int domain_size)
{
if (VARIABLE(t) || CONSTANT(t))
return TRUE;
else if (arith_rel_term(t) || arith_op_term(t)) {
int i;
for (i = 0; i < ARITY(t); i++) {
if (!all_ordinary_nodes_safe(ARG(t,i), domain_size))
return FALSE;
}
return TRUE;
}
else
return all_safe(t, domain_size);
} /* all_ordinary_nodes_safe */
Winch::Winch(int motorPortA, int motorPortB, int lockPort, int firePort, int potPort)
:
m_MotorA(new Talon(motorPortA)),
m_MotorB(new Talon(motorPortB)),
m_Lock(new Solenoid(lockPort)),
m_Fire(new Solenoid(firePort)),
m_Pot(new AnalogChannel(potPort)),
m_State(UNLOCKING),
m_NextState(RELOADING),
m_Setpoint(CONSTANT("DefaultSetpoint")),
m_PreviousVoltage(0),
m_LastUnlockVoltage(0),
m_HoldVoltage(0),
m_LastFireTime(0),
m_LastFireStopTime(0),
m_LastReloadStopTime(0),
m_InitTime(0)
{
m_Pot->SetAverageBits(6);
}
/**
* @brief Reset the serial number to 1 for an object in memcached.
* @param type the serial type to be queried (OBJECT_USER, OBJECT_CONFIG, OBJECT_FOLDERS, OBJECT_MESSAGES, or OBJECT_CONTACTS).
* @param num the specific object identifier.
* @return 0 on failure or the new value of the cached serial number (1) on success.
*/
uint64_t serial_reset(uint64_t type, uint64_t num) {
uint64_t result = 0;
stringer_t *key, *prefix;
// Build key.
if (!(prefix = serial_prefix(type)) || !(key = st_aprint("magma.%.*s.%lu", st_length_int(prefix), st_char_get(prefix), num))) {
log_pedantic("Unable to build %.*s serial key.", st_length_int(prefix), st_char_get(prefix));
return 0;
}
// If were able to set the key, return the value one.
if (cache_set(key, CONSTANT("1"), 2592000) == 1) {
result = 1;
}
st_free(key);
return result;
}
void Winch::HoldVoltage(double setpoint)
{
if(setpoint < CONSTANT("MaxSetpoint"))
{
return;
}
m_HoldVoltage = setpoint;
if(m_State == RELOADING)
{
m_State = HOLDING;
}
if(m_State == READY_TO_FIRE)
{
m_LastUnlockVoltage = m_Pot->GetAverageVoltage();
m_NextState = HOLDING;
m_State = UNLOCKING;
}
}
} END_TEST
START_TEST (check_credential_auth_creation_s) {
credential_t *cred;
char *errmsg = NULL;
log_unit("%-64.64s", "OBJECTS / USERS / CREDENTIALS / AUTH CREATION / SINGLE THREADED:");
if (!(cred = credential_alloc_auth(CONSTANT("ladar"), CONSTANT("test")))) {
errmsg = "Credential creation failed.";
}
else if (st_cmp_cs_eq(cred->auth.password, CONSTANT("46c3c0f5c777aacbdb0c25b14d6889b98efa62fa0ae551ec067d7aa126392805e3e3a2ce07d36" \
"df7e715e24f35c88105fff5a9eebff0532f990644cf07a4751f"))) {
errmsg = "The credential password hash doesn't match the expected value.";
}
if (cred) {
credential_free(cred);
cred = NULL;
}
if (!errmsg && !(cred = credential_alloc_auth(CONSTANT("*****@*****.**"), CONSTANT("test")))) {
errmsg = "Credential creation failed.";
}
else if (!errmsg && st_cmp_cs_eq(cred->auth.password, CONSTANT("46c3c0f5c777aacbdb0c25b14d6889b98efa62fa0ae551ec067d7aa126392805e3e3a2ce07d36" \
"df7e715e24f35c88105fff5a9eebff0532f990644cf07a4751f"))) {
errmsg = "The credential password hash doesn't match the expected value.";
}
if (cred) {
credential_free(cred);
}
log_unit("%10.10s\n", (!status() ? "SKIPPED" : !errmsg ? "PASSED" : "FAILED"));
fail_unless(!errmsg, errmsg);
} END_TEST
FUN_IEIZ2E2p (gluBuild2DMipmaps)
FUN_vD9 (gluLookAt)
FUN_vD4 (gluOrtho2D)
FUN_vD4 (gluPerspective)
FUN_vD4p (gluPickMatrix)
FUN_iD3p6(gluProject)
/* gluScaleImage */
FUN_iD3p6(gluUnProject)
void register_glut(lua_State *L)
{
/* as extracted from glut.h version 3.7 */
#if !defined(USE_OPENGLEAN)
CONSTANT(GLUT_API_VERSION)
#endif
/* CONSTANT(GLUT_XLIB_IMPLEMENTATION) not in freeglut <= 2.2.0 */
CONSTANT(GLUT_RGB)
CONSTANT(GLUT_RGBA)
CONSTANT(GLUT_INDEX)
CONSTANT(GLUT_SINGLE)
CONSTANT(GLUT_DOUBLE)
CONSTANT(GLUT_ACCUM)
CONSTANT(GLUT_ALPHA)
CONSTANT(GLUT_DEPTH)
CONSTANT(GLUT_STENCIL)
CONSTANT(GLUT_MULTISAMPLE)
CONSTANT(GLUT_STEREO)
CONSTANT(GLUT_LUMINANCE)
CONSTANT(GLUT_LEFT_BUTTON)
/* PUBLIC */
Term read_commands(FILE *fin, FILE *fout, BOOL echo, int unknown_action)
{
Term t = read_term(fin, fout);
BOOL go = (t != NULL);
while (go) {
BOOL already_echoed = FALSE;
/************************************************************ set, clear */
if (is_term(t, "set", 1) || is_term(t, "clear", 1)) {
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
flag_handler(fout, t, unknown_action);
}
else if (is_term(t, "assign", 2)) {
/************************************************************** assign */
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
parm_handler(fout, t, unknown_action);
}
else if (is_term(t, "assoc_comm", 1) ||
is_term(t, "commutative", 1)) {
/************************************************************ AC, etc. */
Term f = ARG(t,0);
if (!CONSTANT(f)) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("argument must be symbol only");
}
else {
if (is_term(t, "assoc_comm", 1))
set_assoc_comm(sn_to_str(SYMNUM(f)), TRUE);
else
set_commutative(sn_to_str(SYMNUM(f)), TRUE);
}
}
else if (is_term(t, "op", 3)) {
/****************************************************************** op */
/* e.g., op(300, infix, +); */
Term prec_term = ARG(t,0);
Term type_term = ARG(t,1);
Term symb_term = ARG(t,2);
int prec;
BOOL ok = term_to_int(prec_term, &prec);
if (!ok || prec < MIN_PRECEDENCE || prec > MAX_PRECEDENCE) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("bad precedence in op command");
}
else if (proper_listterm(symb_term)) {
while (cons_term(symb_term)) {
process_op(fout, t, prec, type_term, ARG(symb_term, 0));
symb_term = ARG(symb_term, 1);
}
}
else
process_op(fout, t, prec, type_term, symb_term);
}
else if (is_term(t, "lex", 1)) {
/***************************************************************** lex */
Plist p = listterm_to_tlist(ARG(t,0));
if (p == NULL) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("lex command must contain a proper list, e.g., [a,b,c]");
}
else {
preliminary_precedence(p);
zap_plist(p);
}
}
else {
/******************************************************** unrecognized */
/* return this unknown term */
go = FALSE;
}
if (go) {
if (echo && !already_echoed)
fwrite_term_nl(fout, t);
zap_term(t);
t = read_term(fin, fout);
go = (t != NULL);
}
}
return t;
} /* read_commands */
/*
On the PC Jr the input for clock 1 seems to be selectable
based on bit 4(/5?) written to output port A0h. This is not
supported yet.
*/
MCFG_DEVICE_ADD("pit8253", PIT8253, 0)
MCFG_PIT8253_CLK0(XTAL_14_31818MHz/12)
MCFG_PIT8253_OUT0_HANDLER(DEVWRITELINE("pic8259", pic8259_device, ir0_w))
MCFG_PIT8253_CLK1(XTAL_14_31818MHz/12)
MCFG_PIT8253_CLK2(XTAL_14_31818MHz/12)
MCFG_PIT8253_OUT2_HANDLER(WRITELINE(pcjr_state, out2_changed))
MCFG_PIC8259_ADD( "pic8259", WRITELINE(pcjr_state, pic8259_set_int_line), VCC, NULL )
MCFG_DEVICE_ADD("ppi8255", I8255, 0)
MCFG_I8255_IN_PORTA_CB(CONSTANT(0xff))
MCFG_I8255_OUT_PORTB_CB(WRITE8(pcjr_state, pcjr_ppi_portb_w))
MCFG_I8255_IN_PORTC_CB(READ8(pcjr_state, pcjr_ppi_portc_r))
MCFG_DEVICE_ADD( "ins8250", INS8250, XTAL_1_8432MHz )
MCFG_INS8250_OUT_TX_CB(DEVWRITELINE("serport", rs232_port_device, write_txd))
MCFG_INS8250_OUT_DTR_CB(DEVWRITELINE("serport", rs232_port_device, write_dtr))
MCFG_INS8250_OUT_RTS_CB(DEVWRITELINE("serport", rs232_port_device, write_rts))
MCFG_INS8250_OUT_INT_CB(DEVWRITELINE("pic8259", pic8259_device, ir3_w))
MCFG_RS232_PORT_ADD( "serport", pcjr_com, nullptr )
MCFG_RS232_RXD_HANDLER(DEVWRITELINE("ins8250", ins8250_uart_device, rx_w))
MCFG_RS232_DCD_HANDLER(DEVWRITELINE("ins8250", ins8250_uart_device, dcd_w))
MCFG_RS232_DSR_HANDLER(DEVWRITELINE("ins8250", ins8250_uart_device, dsr_w))
MCFG_RS232_RI_HANDLER(DEVWRITELINE("ins8250", ins8250_uart_device, ri_w))
MCFG_RS232_CTS_HANDLER(DEVWRITELINE("ins8250", ins8250_uart_device, cts_w))
init_cairo(void)
{
PyObject *m;
/* initialise 'tp_base' here to work round problem with MinGW compiler */
PycairoContext_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoContext_Type) < 0)
return;
PycairoFontFace_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoFontFace_Type) < 0)
return;
PycairoToyFontFace_Type.tp_base = &PycairoFontFace_Type;
if (PyType_Ready(&PycairoToyFontFace_Type) < 0)
return;
PycairoFontOptions_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoFontOptions_Type) < 0)
return;
PycairoMatrix_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoMatrix_Type) < 0)
return;
PycairoPath_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoPath_Type) < 0)
return;
PycairoPathiter_Type.tp_iter=&PyObject_SelfIter;
PycairoPattern_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoPattern_Type) < 0)
return;
PycairoSolidPattern_Type.tp_base = &PycairoPattern_Type;
if (PyType_Ready(&PycairoSolidPattern_Type) < 0)
return;
PycairoSurfacePattern_Type.tp_base = &PycairoPattern_Type;
if (PyType_Ready(&PycairoSurfacePattern_Type) < 0)
return;
PycairoGradient_Type.tp_base = &PycairoPattern_Type;
if (PyType_Ready(&PycairoGradient_Type) < 0)
return;
PycairoLinearGradient_Type.tp_base = &PycairoGradient_Type;
if (PyType_Ready(&PycairoLinearGradient_Type) < 0)
return;
PycairoRadialGradient_Type.tp_base = &PycairoGradient_Type;
if (PyType_Ready(&PycairoRadialGradient_Type) < 0)
return;
PycairoScaledFont_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoScaledFont_Type) < 0)
return;
PycairoSurface_Type.tp_base = &PyBaseObject_Type;
if (PyType_Ready(&PycairoSurface_Type) < 0)
return;
#ifdef CAIRO_HAS_IMAGE_SURFACE
PycairoImageSurface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoImageSurface_Type) < 0)
return;
#endif
#ifdef CAIRO_HAS_PDF_SURFACE
PycairoPDFSurface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoPDFSurface_Type) < 0)
return;
#endif
#ifdef CAIRO_HAS_PS_SURFACE
PycairoPSSurface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoPSSurface_Type) < 0)
return;
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
PycairoSVGSurface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoSVGSurface_Type) < 0)
return;
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
PycairoWin32Surface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoWin32Surface_Type) < 0)
return;
#endif
#ifdef CAIRO_HAS_XLIB_SURFACE
PycairoXlibSurface_Type.tp_base = &PycairoSurface_Type;
if (PyType_Ready(&PycairoXlibSurface_Type) < 0)
return;
#endif
m = Py_InitModule("cairo._cairo", cairo_functions);
PyModule_AddStringConstant(m, "version", pycairo_version_string);
PyModule_AddObject(m, "version_info",
Py_BuildValue("(iii)", VERSION_MAJOR, VERSION_MINOR,
VERSION_MICRO));
Py_INCREF(&PycairoContext_Type);
PyModule_AddObject(m, "Context", (PyObject *)&PycairoContext_Type);
Py_INCREF(&PycairoFontFace_Type);
PyModule_AddObject(m, "FontFace",(PyObject *)&PycairoFontFace_Type);
Py_INCREF(&PycairoToyFontFace_Type);
PyModule_AddObject(m, "ToyFontFace",(PyObject *)&PycairoToyFontFace_Type);
Py_INCREF(&PycairoFontOptions_Type);
PyModule_AddObject(m, "FontOptions",(PyObject *)&PycairoFontOptions_Type);
Py_INCREF(&PycairoMatrix_Type);
PyModule_AddObject(m, "Matrix", (PyObject *)&PycairoMatrix_Type);
Py_INCREF(&PycairoPath_Type);
/* Don't add Path object since it is not accessed directly as 'cairo.Path'
* PyModule_AddObject(m, "Path", (PyObject *)&PycairoPath_Type);
*/
Py_INCREF(&PycairoPattern_Type);
PyModule_AddObject(m, "Pattern", (PyObject *)&PycairoPattern_Type);
Py_INCREF(&PycairoSolidPattern_Type);
PyModule_AddObject(m, "SolidPattern",
(PyObject *)&PycairoSolidPattern_Type);
Py_INCREF(&PycairoSurfacePattern_Type);
PyModule_AddObject(m, "SurfacePattern",
(PyObject *)&PycairoSurfacePattern_Type);
Py_INCREF(&PycairoGradient_Type);
PyModule_AddObject(m, "Gradient", (PyObject *)&PycairoGradient_Type);
Py_INCREF(&PycairoLinearGradient_Type);
PyModule_AddObject(m, "LinearGradient",
(PyObject *)&PycairoLinearGradient_Type);
Py_INCREF(&PycairoRadialGradient_Type);
PyModule_AddObject(m, "RadialGradient",
(PyObject *)&PycairoRadialGradient_Type);
Py_INCREF(&PycairoScaledFont_Type);
PyModule_AddObject(m, "ScaledFont", (PyObject *)&PycairoScaledFont_Type);
Py_INCREF(&PycairoSurface_Type);
PyModule_AddObject(m, "Surface", (PyObject *)&PycairoSurface_Type);
#ifdef CAIRO_HAS_IMAGE_SURFACE
Py_INCREF(&PycairoImageSurface_Type);
PyModule_AddObject(m, "ImageSurface",
(PyObject *)&PycairoImageSurface_Type);
#endif
#ifdef CAIRO_HAS_PDF_SURFACE
Py_INCREF(&PycairoPDFSurface_Type);
PyModule_AddObject(m, "PDFSurface", (PyObject *)&PycairoPDFSurface_Type);
#endif
#ifdef CAIRO_HAS_PS_SURFACE
Py_INCREF(&PycairoPSSurface_Type);
PyModule_AddObject(m, "PSSurface", (PyObject *)&PycairoPSSurface_Type);
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
Py_INCREF(&PycairoSVGSurface_Type);
PyModule_AddObject(m, "SVGSurface", (PyObject *)&PycairoSVGSurface_Type);
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
Py_INCREF(&PycairoWin32Surface_Type);
PyModule_AddObject(m, "Win32Surface",
(PyObject *)&PycairoWin32Surface_Type);
#endif
#ifdef CAIRO_HAS_XLIB_SURFACE
Py_INCREF(&PycairoXlibSurface_Type);
PyModule_AddObject(m, "XlibSurface",
(PyObject *)&PycairoXlibSurface_Type);
#endif
PyModule_AddObject(m, "CAPI", PyCObject_FromVoidPtr(&CAPI, NULL));
/* Add 'cairo.Error' to the module */
if (CairoError == NULL) {
CairoError = PyErr_NewException("cairo.Error", NULL, NULL);
if (CairoError == NULL)
return;
}
Py_INCREF(CairoError);
if (PyModule_AddObject(m, "Error", CairoError) < 0)
return;
/* constants */
#if CAIRO_HAS_ATSUI_FONT
PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 0);
#endif
#if CAIRO_HAS_FT_FONT
PyModule_AddIntConstant(m, "HAS_FT_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_FT_FONT", 0);
#endif
#if CAIRO_HAS_GLITZ_SURFACE
PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 0);
#endif
#if CAIRO_HAS_IMAGE_SURFACE
PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 0);
#endif
#if CAIRO_HAS_PDF_SURFACE
PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 0);
#endif
#if CAIRO_HAS_PNG_FUNCTIONS
PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 1);
#else
PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 0);
#endif
#if CAIRO_HAS_PS_SURFACE
PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 0);
#endif
#if CAIRO_HAS_SVG_SURFACE
PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 0);
#endif
#if CAIRO_HAS_USER_FONT
PyModule_AddIntConstant(m, "HAS_USER_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_USER_FONT", 0);
#endif
#if CAIRO_HAS_QUARTZ_SURFACE
PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 0);
#endif
#if CAIRO_HAS_WIN32_FONT
PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 0);
#endif
#if CAIRO_HAS_WIN32_SURFACE
PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 0);
#endif
#if CAIRO_HAS_XCB_SURFACE
PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 0);
#endif
#if CAIRO_HAS_XLIB_SURFACE
PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 0);
#endif
#define CONSTANT(x) PyModule_AddIntConstant(m, #x, CAIRO_##x)
CONSTANT(ANTIALIAS_DEFAULT);
CONSTANT(ANTIALIAS_NONE);
CONSTANT(ANTIALIAS_GRAY);
CONSTANT(ANTIALIAS_SUBPIXEL);
CONSTANT(CONTENT_COLOR);
CONSTANT(CONTENT_ALPHA);
CONSTANT(CONTENT_COLOR_ALPHA);
CONSTANT(EXTEND_NONE);
CONSTANT(EXTEND_REPEAT);
CONSTANT(EXTEND_REFLECT);
CONSTANT(EXTEND_PAD);
CONSTANT(FILL_RULE_WINDING);
CONSTANT(FILL_RULE_EVEN_ODD);
CONSTANT(FILTER_FAST);
CONSTANT(FILTER_GOOD);
CONSTANT(FILTER_BEST);
CONSTANT(FILTER_NEAREST);
CONSTANT(FILTER_BILINEAR);
CONSTANT(FILTER_GAUSSIAN);
CONSTANT(FONT_WEIGHT_NORMAL);
CONSTANT(FONT_WEIGHT_BOLD);
CONSTANT(FONT_SLANT_NORMAL);
CONSTANT(FONT_SLANT_ITALIC);
CONSTANT(FONT_SLANT_OBLIQUE);
CONSTANT(FORMAT_ARGB32);
CONSTANT(FORMAT_RGB24);
CONSTANT(FORMAT_A8);
CONSTANT(FORMAT_A1);
CONSTANT(HINT_METRICS_DEFAULT);
CONSTANT(HINT_METRICS_OFF);
CONSTANT(HINT_METRICS_ON);
CONSTANT(HINT_STYLE_DEFAULT);
CONSTANT(HINT_STYLE_NONE);
CONSTANT(HINT_STYLE_SLIGHT);
CONSTANT(HINT_STYLE_MEDIUM);
CONSTANT(HINT_STYLE_FULL);
CONSTANT(LINE_CAP_BUTT);
CONSTANT(LINE_CAP_ROUND);
CONSTANT(LINE_CAP_SQUARE);
CONSTANT(LINE_JOIN_MITER);
CONSTANT(LINE_JOIN_ROUND);
CONSTANT(LINE_JOIN_BEVEL);
CONSTANT(OPERATOR_CLEAR);
CONSTANT(OPERATOR_SOURCE);
CONSTANT(OPERATOR_OVER);
CONSTANT(OPERATOR_IN);
CONSTANT(OPERATOR_OUT);
CONSTANT(OPERATOR_ATOP);
CONSTANT(OPERATOR_DEST);
CONSTANT(OPERATOR_DEST_OVER);
CONSTANT(OPERATOR_DEST_IN);
CONSTANT(OPERATOR_DEST_OUT);
CONSTANT(OPERATOR_DEST_ATOP);
CONSTANT(OPERATOR_XOR);
CONSTANT(OPERATOR_ADD);
CONSTANT(OPERATOR_SATURATE);
CONSTANT(PATH_MOVE_TO);
CONSTANT(PATH_LINE_TO);
CONSTANT(PATH_CURVE_TO);
CONSTANT(PATH_CLOSE_PATH);
#ifdef CAIRO_HAS_PS_SURFACE
CONSTANT(PS_LEVEL_2);
CONSTANT(PS_LEVEL_3);
#endif
CONSTANT(SUBPIXEL_ORDER_DEFAULT);
CONSTANT(SUBPIXEL_ORDER_RGB);
CONSTANT(SUBPIXEL_ORDER_BGR);
CONSTANT(SUBPIXEL_ORDER_VRGB);
CONSTANT(SUBPIXEL_ORDER_VBGR);
#undef CONSTANT
}
void SetSegment( SYMPTR sym )
{
segment_list *seg;
target_size size;
#if _CPU == 8086
if( (sym->mods & FLAG_FAR) && CompFlags.zc_switch_used ) {
if( CONSTANT( sym->mods )
|| (sym->attribs.stg_class == SC_STATIC && (sym->flags & SYM_TEMP)) ) {
sym->u.var.segid = SEG_CODE;
return;
}
}
#elif _CPU == 386
if( !CompFlags.rent ) {
if( (sym->mods & FLAG_FAR) || (TargetSwitches & FLAT_MODEL) ) {
if( CONSTANT( sym->mods ) && CompFlags.zc_switch_used ) {
sym->u.var.segid = SEG_CODE;
return;
}
if( (sym->attribs.stg_class == SC_STATIC) && (sym->flags & SYM_TEMP) ) {
sym->u.var.segid = SEG_CODE;
return;
}
}
}
#endif
if( sym->mods & ( FLAG_FAR | FLAG_HUGE ) ) {
size = SizeOfArg( sym->sym_type );
seg = NULL;
#if _CPU == 8086
if( size < 0x10000 ) {
for( seg = SegListHead; seg != NULL; seg = seg->next_segment ) {
if( seg->size_left >= size ) {
break;
}
}
}
#else
seg = SegListHead;
#endif
if( seg == NULL ) {
if( SegListHead == NULL ) {
SegListHead = CMemAlloc( sizeof( segment_list ) );
seg = SegListHead;
} else {
for( seg = SegListHead; seg->next_segment; ) {
seg = seg->next_segment;
}
seg->next_segment = CMemAlloc( sizeof( segment_list ) );
seg = seg->next_segment;
}
seg->segid = SegmentNum++;
#if _CPU == 8086
if( size > 0xFFFF ) {
while( size > 0x0FFFF ) { /* while >= 64K */
++SegmentNum;
size -= 0x10000;
}
seg->size_left = 0;
} else {
seg->size_left = 0x10000 - size;
}
#endif
} else {
seg->size_left -= size;
}
sym->u.var.segid = seg->segid;
} else {
sym->u.var.segid = SymSegId( sym );
}
}
void OperatorController::handle(CowRobot *bot)
{
//printf("Controlling...\n");
if(m_CB->GetDriveButton(1))
{
bot->DriveDistanceWithHeading(0, 12);
}
else
{
bot->DriveSpeedTurn(m_CB->GetDriveStickY(),
m_CB->GetSteeringX(),
m_CB->GetSteeringButton(FAST_TURN));
}
if(m_CB->GetSteeringButton(1))
{
bot->GetPincher()->ManualControl(1, 0);
bot->GetPincher()->EnablePositionPID();
}
else if(m_CB->GetSteeringButton(3))
{
bot->GetPincher()->ManualControl(-1, 0);
bot->GetPincher()->EnablePositionPID();
}
if(!m_CB->GetSteeringButton(1) && !m_CB->GetSteeringButton(3))
{
bot->GetPincher()->ManualControl(0, 0);
}
if(m_CB->GetOperatorButton(8))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_ONE_TOTE"));
}
else if(m_CB->GetOperatorButton(6))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_TWO_TOTE"));
}
else if(m_CB->GetOperatorButton(7))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_THREE_TOTE"));
}
else if(m_CB->GetOperatorButton(2))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_FOUR_TOTE"));
}
else if(m_CB->GetOperatorButton(5))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_THREE_CAN"));
}
if(m_CB->GetSteeringButton(2))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_BASE_TOTE"));
}
float vLiftJoystick = CowLib::Deadband(m_CB->GetOperatorGamepadAxis(1), 0.2) * 1.5;
// float hLiftJoystick = CowLib::Deadband(m_CB->GetOperatorGamepadAxis(0), 0.4) * 1.5;
bot->GetVerticalLift()->UpdateSetPoint(bot->GetVerticalLift()->GetPosition() + vLiftJoystick);
//bot->GetHorizontalLift()->UpdateSetPoint(bot->GetHorizontalLift()->GetPosition() + hLiftJoystick);
if(m_CB->GetOperatorButton(3))
{
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_OPEN"));
bot->GetPincher()->EnablePositionPID();
}
else if(m_CB->GetOperatorButton(4))
{
bot->GetVerticalLift()->UpdateSetPoint(0);
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_CAN"));
bot->GetPincher()->EnablePositionPID();
}
else if(m_CB->GetOperatorButton(9))
{
bot->GetVerticalLift()->UpdateSetPoint(CONSTANT("VERTICAL_HUMAN_PLAYER"));
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_CAN"));
bot->GetPincher()->ManualControl(-1, 0);
bot->GetPincher()->EnablePositionPID();
}
else if(m_CB->GetOperatorButton(10))
{
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_CAN"));
bot->GetPincher()->EnablePositionPID();
}
if(m_CB->GetOperatorButton(1))
{
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_RIGHTING"));
bot->GetPincher()->EnablePositionPID();
// bot->GetPincher()->Spin(true);
// bot->GetPincher()->ManualControl(-1, 0);
}
// else
// {
bot->GetPincher()->Spin(false);
//}
if(!m_CB->GetOperatorButton(10))
{
if(!setPinchOnce)
{
bot->GetPincher()->UpdateSetPoint(CONSTANT("PINCHER_OPEN"));
bot->GetPincher()->EnablePositionPID();
setPinchOnce = true;
}
bot->GetPincher()->PositionMode();
}
else
{
bot->GetPincher()->GrabMode();
setPinchOnce = false;
}
}
int
ParseEQUALS (ParseInput_t *InRecord, ParseOutput_t *OutRecord)
{
Address_t LabelValue = { 1 };
int Value, i;
OutRecord->ProgramCounter = InRecord->ProgramCounter;
OutRecord->Bank = InRecord->Bank;
OutRecord->LabelValue.Invalid = 1;
OutRecord->NumWords = 0;
OutRecord->Equals = 1;
// As a special case, it sometimes happens that the label is empty.
// I *believe* that this is done only for documentation purposes, and
// has no other effect.
if (*InRecord->Label == 0)
{
OutRecord->LabelValueValid = 0;
return (0);
}
// As another special case, there is sometimes no operand. *That* means
// that the current program counter is the value.
if (*InRecord->Operand == 0 && *InRecord->Mod1 == 0)
{
// JMS: Even though it is assigned the program counter as the current
// value, it is still just a constant
//EditSymbol (InRecord->Label, &InRecord->ProgramCounter);
EditSymbolNew (InRecord->Label, &InRecord->ProgramCounter, SYMBOL_CONSTANT,
CurrentFilename, CurrentLineInFile);
OutRecord->LabelValue = InRecord->ProgramCounter;
return (0);
}
// Next, it may be that the operand is simply a number. If so, then
// we're talking about a simple constant.
i = GetOctOrDec (InRecord->Operand, &Value);
if (i)
{
// The operand is NOT a number. Presumably, it's a symbol.
i = FetchSymbolPlusOffset (&InRecord->ProgramCounter,
InRecord->Operand,
InRecord->Mod1, &LabelValue);
if (i)
{
sprintf(OutRecord->ErrorMessage, "Symbol \"%s\" undefined or offset bad", InRecord->Operand);
OutRecord->Fatal = 1;
return (0);
}
#if 0
if (!i)
{
LabelValue = CONSTANT (0);
LabelValue.Value = Value;
EditSymbol (InRecord->Label, &LabelValue);
}
#endif
if (OpcodeOffset)
{
if (LabelValue.Constant)
{
LabelValue.Value += OpcodeOffset;
}
else
IncPc (&LabelValue, OpcodeOffset, &LabelValue);
}
// JMS: This is just a constant to add to the symbol table
//EditSymbol (InRecord->Label, &LabelValue);
EditSymbolNew (InRecord->Label, &LabelValue, SYMBOL_CONSTANT,
CurrentFilename, CurrentLineInFile);
OutRecord->LabelValueValid = 1;
}
else
{
ParseOutput_t TempOutput;
if (*InRecord->Operand == '+' || *InRecord->Operand == '-')
{
IncPc (&InRecord->ProgramCounter, Value, &LabelValue);
}
else
{
if (Value < -16383 || Value > 32767)
{
strcpy (OutRecord->ErrorMessage, "Value out of range---truncating");
OutRecord->Warning = 1;
if (Value < -16383)
Value = -16383;
else if (Value > 32767)
Value = 32767;
}
LabelValue.Invalid = 0;
LabelValue.Constant = 1;
LabelValue.Value = Value;
PseudoToSegmented (Value, &TempOutput);
}
// JMS: This is just a constant to add to the symbol table
//EditSymbol (InRecord->Label, &LabelValue /*&TempOutput.ProgramCounter*/);
EditSymbolNew (InRecord->Label, &LabelValue, SYMBOL_CONSTANT,
CurrentFilename, CurrentLineInFile);
}
OutRecord->LabelValue = LabelValue;
return (0);
}
AutoModes::AutoModes()
{
// Set up our selection order
m_Modes["Can Burglar!"];
m_Modes["Can Burglar!"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, 0, 0, true, 0.545));
m_Modes["Can Burglar!"].push_back(RobotCommand(CMD_HOLD_DISTANCE, 100, 0, 0, PINCH, 0, 0, true, 2));
m_Modes["Can Burglar!"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, 0, 0, false, 1));
m_Modes["Can Burglar!"].push_back(RobotCommand(CMD_HOLD_DISTANCE, 24, 0, 0, PINCH, 0, 0, false, 2));
m_Modes["Nothing"];
m_Modes["Nothing"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), 0, false, 1));
m_Modes["Two Can"];
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), 0, false, 0.1875));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.1875));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.125));
m_Modes["Two Can"].push_back(RobotCommand(CMD_TURN, 0, 90, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.5));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 70, 90, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 30, 100, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 30, 120, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 60, 150, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 150, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.375));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 150, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -30, 150, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Two Can"].push_back(RobotCommand(CMD_TURN, 0, 0, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 36, 0, 0, PINCH, 0, -1, false, 1.5));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 0.625));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -1, false, 0.625));
m_Modes["Two Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -90, 0, CONSTANT("VERTICAL_BASE_TOTE"), PINCH, CONSTANT("PINCHER_CAN"), -1, false, 1.5));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.375));
m_Modes["Two Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Three Can"];
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), 0, false, 0.1875));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.1875));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.125));
m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, 90, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.5));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 70, 90, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 30, 100, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 30, 120, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 60, 150, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.45));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 150, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 150, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -40, 150, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, 0, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 45, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 0.625));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -1, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), -0.5, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, -180, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), -0.5, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 65, -180, CONSTANT("VERTICAL_BASE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), 0, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, -180, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, -180, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -72, -180, 0, PINCH, 0, 0, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, -90, 0, PINCH, 0, 0, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 130, -90, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 1.5));
m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, -180, CONSTANT("VERTICAL_BASE_TOTE") - 3, GRAB, CONSTANT("PINCHER_CAN"), -0.5, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 60, -180, CONSTANT("VERTICAL_BASE_TOTE") - 3, GRAB, CONSTANT("PINCHER_CAN"), -0.5, false, 1));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), 0, false, 0.375));
m_Modes["Three Can"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, 0, 0, false, 0.375));
// m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 45, 230, 0, PINCH, 0, 0, 0.75));
// m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 60, 270, 0, PINCH, 0, 0, 0.75));
// m_Modes["Three Can"].push_back(RobotCommand(CMD_TURN, 0, 270, 0, PINCH, 0, -0.5, 1));
// m_Modes["Three Can"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 110, 270, 0, PINCH, 0, 0, 2));
m_Modes["Two Tote"];
m_Modes["Two Tote"].push_back(RobotCommand(CMD_TURN, 0, -45, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 12, -45, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -12, -45, 0, GRAB, CONSTANT("PINCHER_CAN"), -1, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_TURN, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -1, false, 0.375));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 130, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 1.875));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -45, 0, 0, PINCH, 0, 0, false, 1));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_TURN, 0, -45, 0, PINCH, 0, 0, false, 0.375));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 22, -45, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -18, -45, 0, GRAB, CONSTANT("PINCHER_CAN"), -1, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_TURN, 0, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 48.5, 0, CONSTANT("VERTICAL_ONE_TOTE"), GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 0.75));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_WAIT, 48.5, 0, CONSTANT("VERTICAL_ONE_TOTE"), PINCH, 0, 0, false, 0.6));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -5, 0, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 10, 0, 0, PINCH, 0, 0, false, 0.5));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, PINCH, CONSTANT("PINCHER_CAN"), -1, false, 0.1875));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 80, 0, 0, GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 0.50));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_TURN_WITH_TOTE, 0, 90, 0, GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 1));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 90, 90, 0, GRAB, CONSTANT("PINCHER_CAN"), -0.2, false, 0.6));
m_Modes["Two Tote"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -70, 90, 0, PINCH, 0, 0, false, 0.6));
// m_Modes["Default"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -170, 90, 0, PINCH, 0, 0, 1));
// m_Modes["Default"].push_back(RobotCommand(CMD_TURN, 0, 0, 0, PINCH, 0, 0, 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -10, 0, 0, PINCH, 0, 0, 0.25));
// m_Modes["Default"].push_back(RobotCommand(CMD_TURN, 0, -45, 0, PINCH, 0, 0, 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, 0.75));
//dont run this for now
// m_Modes["Default"].push_back(RobotCommand(CMD_TURN, 0, -45, 0, 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 12, -45, 0, 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, -12, -45, 0, 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_TURN, 0, 90, CONSTANT("VERTICAL_TWO_TOTE"), 0.75));
// m_Modes["Default"].push_back(RobotCommand(CMD_DRIVE_DISTANCE, 90, 90, CONSTANT("VERTICAL_TWO_TOTE"), 1.5));
//
// m_Modes["Default"].push_back(RobotCommand(CMD_WAIT, 0, 0, 0, 5));
m_Iterator = m_Modes.begin();
}
AM_RANGE(0xf000, 0xf000) AM_WRITENOP
ADDRESS_MAP_END
static INPUT_PORTS_START( bingowav )
INPUT_PORTS_END
static MACHINE_CONFIG_START( bingowav )
MCFG_CPU_ADD("maincpu", M68000, 12000000) // actually TMP63803F-16
MCFG_CPU_PROGRAM_MAP(bingowav_main_map)
MCFG_DEVICE_ADD("maintmp", TMP68301, 0) // wrong
MCFG_DEVICE_ADD("mainioh", TE7750, 0)
MCFG_TE7750_IOS_CB(CONSTANT(5))
MCFG_DEVICE_ADD("mainiol", TE7750, 0)
MCFG_TE7750_IOS_CB(CONSTANT(4))
MCFG_CPU_ADD("audiocpu", Z80, 4000000)
MCFG_CPU_PROGRAM_MAP(bingowav_audio_map)
MCFG_SPEAKER_STANDARD_MONO("mono")
MCFG_SOUND_ADD("ymsnd", YM2610, 8000000)
MCFG_YM2610_IRQ_HANDLER(INPUTLINE("audiocpu", 0))
MCFG_SOUND_ROUTE(0, "mono", 0.25)
MCFG_SOUND_ROUTE(1, "mono", 1.0)
MCFG_SOUND_ROUTE(2, "mono", 1.0)
static MACHINE_CONFIG_START( s7, s7_state )
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", M6808, 3580000)
MCFG_CPU_PROGRAM_MAP(s7_main_map)
MCFG_MACHINE_RESET_OVERRIDE(s7_state, s7)
/* Video */
MCFG_DEFAULT_LAYOUT(layout_s7)
/* Sound */
MCFG_FRAGMENT_ADD( genpin_audio )
/* Devices */
MCFG_DEVICE_ADD("pia21", PIA6821, 0)
MCFG_PIA_READPA_HANDLER(CONSTANT(0xff))
MCFG_PIA_READPB_HANDLER(CONSTANT(0x3f))
MCFG_PIA_WRITEPA_HANDLER(WRITE8(s7_state, sound_w))
MCFG_PIA_WRITEPB_HANDLER(WRITE8(s7_state, sol2_w))
MCFG_PIA_CA2_HANDLER(WRITELINE(s7_state, pia21_ca2_w))
MCFG_PIA_CB2_HANDLER(WRITELINE(s7_state, pia21_cb2_w))
MCFG_PIA_IRQA_HANDLER(WRITELINE(s7_state, pia_irq))
MCFG_PIA_IRQB_HANDLER(WRITELINE(s7_state, pia_irq))
MCFG_DEVICE_ADD("pia22", PIA6821, 0)
MCFG_PIA_WRITEPA_HANDLER(WRITE8(s7_state, sol0_w))
MCFG_PIA_WRITEPB_HANDLER(WRITE8(s7_state, sol1_w))
MCFG_PIA_CA2_HANDLER(WRITELINE(s7_state, pia22_ca2_w))
MCFG_PIA_CB2_HANDLER(WRITELINE(s7_state, pia22_cb2_w))
MCFG_PIA_IRQA_HANDLER(WRITELINE(s7_state, pia_irq))
MCFG_PIA_IRQB_HANDLER(WRITELINE(s7_state, pia_irq))