static VALUE rbosa_element_data (int argc, VALUE *argv, VALUE self) { VALUE coerce_type; AEDesc coerced_desc; AEDesc * desc; OSErr error; void * data; Size datasize; VALUE retval; bool to_4cc; rb_scan_args (argc, argv, "01", &coerce_type); to_4cc = false; desc = rbosa_element_aedesc (self); if (!NIL_P (coerce_type)) { FourCharCode code; code = RVAL2FOURCHAR (coerce_type); error = AECoerceDesc (desc, code, &coerced_desc); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot coerce desc to type %s : %s (%d)", RVAL2CSTR (coerce_type), error_code_to_string (error), error); desc = &coerced_desc; to_4cc = code == 'type'; } datasize = AEGetDescDataSize (desc); data = (void *)malloc (datasize); if (data == NULL) rb_fatal ("cannot allocate memory"); error = AEGetDescData (desc, data, datasize); if (error == noErr) { if (to_4cc) *(DescType*)data = CFSwapInt32HostToBig (*(DescType*)data); retval = rb_str_new (data, datasize); } else { retval = Qnil; } if (!NIL_P (coerce_type)) AEDisposeDesc (&coerced_desc); free (data); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot get desc data : %s (%d)", error_code_to_string (error), error); return retval; }
int load_param_values(struct SSettings* psettings) { assert(psettings != NULL); assert(psettings->val_path != NULL); assert(psettings->values == NULL); psettings->values = smap_create(); if (psettings->values == NULL) { print_error(errNoMemory); return 0; } char* err = NULL; EMistErrorCode ec = mist_load_config_file(psettings->val_path, psettings->values, &err); if (ec != MIST_OK) { // psettings->values may contain some data now. It is OK, the data // will be destroyed when cleanup_settings() is called. print_error(errFailedToLoadValues, psettings->val_path, (err != NULL ? err : error_code_to_string(ec))); free(err); return 0; } return 1; }
int vrpn_Nikon_Controls::reset(void) { unsigned char inbuf[256]; int ret; char errmsg[256]; char cmd[256]; double response_pos; //< Where the focus says it is. //----------------------------------------------------------------------- // Sleep a second and then drain the input buffer to make sure we start // with a fresh slate. vrpn_SleepMsecs(1000); vrpn_flush_input_buffer(serial_fd); //----------------------------------------------------------------------- // Send the command to request the focus. Then wait 1 second for a response sprintf(cmd, "rSPR\r"); if (vrpn_write_characters(serial_fd, (unsigned char *)cmd, strlen(cmd)) != (int)strlen(cmd)) { fprintf(stderr,"vrpn_Nikon_Controls::reset(): Cannot send focus request\n"); return -1; } vrpn_SleepMsecs(1000); //----------------------------------------------------------------------- // Read the response from the camera and then see if it is a good response, // an error message, or nothing. ret = vrpn_read_available_characters(serial_fd, inbuf, sizeof(inbuf)); if (ret < 0) { perror("vrpn_Nikon_Controls::reset(): Error reading position from device"); return -1; } if (ret == 0) { fprintf(stderr, "vrpn_Nikon_Controls::reset(): No characters when reading position from device\n"); return -1; } inbuf[ret] = '\0'; //< Null-terminate the input string ret = parse_focus_position_response((char *)inbuf, response_pos); if (ret < 0) { fprintf(stderr,"vrpn_Nikon_Controls::reset(): Error reading focus: %s\n", error_code_to_string((int)(response_pos))); return -1; } if (ret != 1) { fprintf(stderr,"vrpn_Nikon_Controls::reset(): Unexpected response to focus request\n"); return -1; } channel[0] = response_pos; sprintf(errmsg,"Focus reported (this is good)"); VRPN_MSG_WARNING(errmsg); // We're now waiting for any responses from devices status = STATUS_SYNCING; VRPN_MSG_WARNING("reset complete (this is good)"); vrpn_gettimeofday(×tamp, NULL); // Set watchdog now return 0; }
static VALUE rbosa_elementlist_new (int argc, VALUE *argv, VALUE self) { OSErr error; AEDescList list; VALUE ary; int i; rb_scan_args (argc, argv, "01", &ary); if (!NIL_P (ary)) Check_Type (ary, T_ARRAY); error = AECreateList (NULL, 0, false, &list); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot create Apple Event descriptor list : %s (%d)", error_code_to_string (error), error); if (!NIL_P (ary)) { for (i = 0; i < RARRAY (ary)->len; i++) __rbosa_elementlist_add (&list, RARRAY (ary)->ptr[i], i + 1); } return rbosa_element_make (self, &list, Qnil); }
static void __rbosa_elementlist_add (AEDescList *list, VALUE element, long pos) { OSErr error; error = AEPutDesc (list, pos, rbosa_element_aedesc (element)); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot add given descriptor : %s (%d)", error_code_to_string (error), error); }
static void __rbosa_raise_potential_app_error (AEDesc *reply) { OSErr error; AEDesc errorNumDesc; AEDesc errorStringDesc; int errorNum; const char * errorMsg; char exception[128]; if (AEGetParamDesc (reply, keyErrorNumber, typeSInt32, &errorNumDesc) != noErr) return; if (AEGetDescData (&errorNumDesc, &errorNum, sizeof errorNum) != noErr) { AEDisposeDesc (&errorNumDesc); return; } if (errorNum == noErr) return; /* The reply is an application error. */ errorMsg = error_code_to_string(errorNum); if (errorMsg == NULL) errorMsg = "Unknown error"; exception[0] = '\0'; error = AEGetParamDesc (reply, keyErrorString, typeChar, &errorStringDesc); if (error == noErr) { Size size; size = AEGetDescDataSize (&errorStringDesc); if (size > 0) { char *msg; msg = (char *)malloc (size + 1); if (msg != NULL) { if (AEGetDescData (&errorStringDesc, msg, size) == noErr) { msg[size] = '\0'; snprintf (exception, sizeof exception, "application returned error: %s (%d), with message: %s", errorMsg, errorNum, msg); } free (msg); } } AEDisposeDesc (&errorStringDesc); } if (exception[0] == '\0') snprintf (exception, sizeof exception, "application returned error: %s (%d)", errorMsg, errorNum); AEDisposeDesc (&errorNumDesc); rb_raise (rb_eRuntimeError, exception); }
static int __rbosa_elementrecord_set (VALUE key, VALUE value, AEDescList *list) { OSErr error; error = AEPutKeyDesc (list, RVAL2FOURCHAR (key), rbosa_element_aedesc (value)); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot set value %p for key %p of record %p: %s (%d)", value, key, list, error_code_to_string (error), error); return ST_CONTINUE; }
static long __rbosa_elementlist_count (AEDescList *list) { OSErr error; long count; error = AECountItems (list, &count); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot count items : %s (%d)", error_code_to_string (error), error); return count; }
static VALUE rbosa_element_dup (VALUE self, VALUE element) { AEDesc * desc; AEDesc new_desc; OSErr error; desc = rbosa_element_aedesc (element); error = AEDuplicateDesc (desc, &new_desc); if (error != noErr) rb_raise (rb_eArgError, "Cannot duplicate element : %s (%d)", error_code_to_string (error), error); return rbosa_element_make (self, &new_desc, Qnil); }
static VALUE __rbosa_elementlist_get (VALUE self, long index, AEKeyword *keyword) { OSErr error; AEDesc desc; error = AEGetNthDesc ((AEDescList *)rbosa_element_aedesc (self), index + 1, typeWildCard, keyword, &desc); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot get desc at index %d : %s (%d)", index, error_code_to_string (error), error); return rbosa_element_make (cOSAElement, &desc, rb_ivar_get (self, sApp)); }
static VALUE rbosa_element_new (VALUE self, VALUE type, VALUE value) { FourCharCode ffc_type; OSErr error; const char * c_value; unsigned c_value_size; AEDesc desc; ffc_type = RVAL2FOURCHAR (type); if (NIL_P (value)) { c_value = NULL; c_value_size = 0; } else if (rb_obj_is_kind_of (value, rb_cInteger)) { FourCharCode code; code = NUM2INT (value); c_value = (const char *)&code; c_value_size = sizeof (FourCharCode); } else if (ffc_type == 'alis') { AliasHandle alias; rbobj_to_alias_handle (value, &alias); c_value = (const char *)*alias; c_value_size = GetHandleSize ((Handle)alias); } else { Check_Type (value, T_STRING); c_value = RSTRING (value)->ptr; c_value_size = RSTRING (value)->len; } error = AECreateDesc (ffc_type, c_value, c_value_size, &desc); if (error != noErr) rb_raise (rb_eArgError, "Cannot create Apple Event descriptor from type '%s' value '%s' : %s (%d)", RVAL2CSTR (type), c_value, error_code_to_string (error), error); return rbosa_element_make (self, &desc, Qnil); }
static VALUE rbosa_element_new_os (VALUE self, VALUE desired_class, VALUE container, VALUE key_form, VALUE key_data) { OSErr error; AEDesc obj_specifier; error = CreateObjSpecifier (RVAL2FOURCHAR (desired_class), rbosa_element_aedesc (container), RVAL2FOURCHAR (key_form), rbosa_element_aedesc (key_data), false, &obj_specifier); if (error != noErr) rb_raise (rb_eArgError, "Cannot create Apple Event object specifier for desired class '%s' : %s (%d)", RVAL2CSTR (desired_class), error_code_to_string (error), error); return rbosa_element_make (self, &obj_specifier, Qnil); }
int generate_output(struct SSettings* psettings) { assert(psettings != NULL); assert(psettings->main_tg != NULL); assert(psettings->is_simplified_mode || psettings->path_tg != NULL); assert(psettings->values != NULL); char* err = NULL; EMistErrorCode ec = MIST_OK; if (psettings->is_simplified_mode) { assert(psettings->path_tg == NULL); ec = mist_tg_set_values_impl(psettings->main_tg, psettings->values); if (ec != MIST_OK) { print_error(errGenResultFailed, error_code_to_string(ec)); return 0; } // generate the contents of the resulting document CGrowingArray* vals = mist_tg_evaluate_impl(psettings->main_tg); if (vals == NULL) { print_error(errGenResultFailed, errNoMemory); return 0; } assert(grar_get_size(vals) > 0); // there should be a single resulting value if (grar_get_size(vals) != 1) { print_error(errGenResultFailed, errMultivaluedResult); return 0; } // output the result to stdout const char* contents = grar_get_element(vals, const char*, 0); assert(contents != NULL); printf("%s", contents); }
static VALUE rbosa_elementrecord_new (int argc, VALUE *argv, VALUE self) { OSErr error; AEDescList list; VALUE hash; rb_scan_args (argc, argv, "01", &hash); if (!NIL_P (hash)) Check_Type (hash, T_HASH); error = AECreateList (NULL, 0, true, &list); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot create Apple Event descriptor list : %s (%d)", error_code_to_string (error), error); if (!NIL_P (hash)) rb_hash_foreach (hash, __rbosa_elementrecord_set, (VALUE)&list); return rbosa_element_make (self, &list, Qnil); }
void attribute::set( const std::string& value ) { VmbErrorType status = VmbErrorSuccess; if( comma::verbose ) { std::cerr << "Setting \"" << name_ << "\" feature"; if( !value.empty() ) { std::cerr << " to " << type_as_string() << " value \"" << value << "\""; } std::cerr << std::endl; } switch( type_ ) { case VmbFeatureDataUnknown: // Unknown feature type COMMA_THROW( comma::exception, "unknown feature \"" << name_ << "\"" ); break; case VmbFeatureDataInt: // 64 bit integer feature status = feature_->SetValue( boost::lexical_cast< VmbInt64_t >( value )); break; case VmbFeatureDataFloat: // 64 bit floating point feature status = feature_->SetValue( boost::lexical_cast< double >( value )); break; case VmbFeatureDataEnum: // Enumeration feature case VmbFeatureDataString: // String feature status = feature_->SetValue( value.c_str() ); break; case VmbFeatureDataBool: // Boolean feature status = feature_->SetValue( boost::lexical_cast< bool >( value )); break; case VmbFeatureDataCommand: // Command feature status = feature_->RunCommand(); if( status == VmbErrorSuccess ) { bool is_command_done = false; do { status = feature_->IsCommandDone( is_command_done ); if( status != VmbErrorSuccess ) break; } while( !is_command_done ); } break; case VmbFeatureDataRaw: // Raw (direct register access) feature COMMA_THROW( comma::exception, "feature \"" << name_ << "\" is a direct register - setting this type is unsupported" ); break; case VmbFeatureDataNone: // Feature with no data COMMA_THROW( comma::exception, "feature \"" << name_ << "\" has no data" ); break; } if( status != VmbErrorSuccess ) { std::string allowed_error_msg; if( !allowed_values_.empty() ) { allowed_error_msg = "; allowed values: "; allowed_error_msg += allowed_values_as_string(); } COMMA_THROW( comma::exception , "failed to set feature \"" << name_ << " to " << value << ", Error: " << status << ": " << error_code_to_string( status ) << allowed_error_msg ); } }
static VALUE rbosa_app_send_event (VALUE self, VALUE event_class, VALUE event_id, VALUE params, VALUE need_retval) { OSErr error; AppleEvent ae; AppleEvent reply; VALUE rb_timeout; SInt32 timeout; VALUE rb_reply; unsigned has_direct_param; error = AECreateAppleEvent (RVAL2FOURCHAR (event_class), RVAL2FOURCHAR (event_id), rbosa_element_aedesc (self), kAutoGenerateReturnID, kAnyTransactionID, &ae); if (error != noErr) rb_raise (rb_eArgError, "Cannot create Apple Event '%s%s' : %s (%d)", RVAL2CSTR (event_class), RVAL2CSTR (event_id), error_code_to_string (error), error); has_direct_param = 0; if (!NIL_P (params)) { unsigned i; for (i = 0; i < RARRAY (params)->len; i++) { VALUE ary; VALUE type; VALUE element; FourCharCode code; ary = RARRAY (params)->ptr[i]; if (NIL_P (ary) || RARRAY (ary)->len != 2) continue; type = RARRAY (ary)->ptr[0]; element = RARRAY (ary)->ptr[1]; code = RVAL2FOURCHAR (type); if (code == '----') has_direct_param = 1; error = AEPutParamDesc (&ae, RVAL2FOURCHAR (type), rbosa_element_aedesc (element)); if (error != noErr) { AEDisposeDesc (&ae); rb_raise (rb_eArgError, "Cannot add Apple Event parameter '%s' : %s (%d)", RVAL2CSTR (type), error_code_to_string (error), error); } } } rb_timeout = rb_iv_get (mOSA, "@timeout"); timeout = NIL_P (rb_timeout) ? kAEDefaultTimeout : NUM2INT (rb_timeout); if (has_direct_param == 0) AEPutAttributePtr (&ae, 'subj', typeNull, NULL, 0); error = AESend (&ae, &reply, (RVAL2CBOOL(need_retval) ? kAEWaitReply : kAENoReply) | kAECanInteract | kAECanSwitchLayer, kAENormalPriority, timeout, NULL, NULL); AEDisposeDesc (&ae); if (error != noErr) rb_raise (rb_eRuntimeError, "Cannot send Apple Event '%s%s' : %s (%d)", RVAL2CSTR (event_class), RVAL2CSTR (event_id), error_code_to_string (error), error); __rbosa_raise_potential_app_error (&reply); if (RTEST (need_retval)) { AEDesc replyObject; AEGetParamDesc (&reply, keyDirectObject, typeWildCard, &replyObject); rb_reply = rbosa_element_make (cOSAElement, &replyObject, self); } else { rb_reply = Qnil; } AEDisposeDesc (&reply); return rb_reply; }
string_t error_t::code_to_string() const { return error_code_to_string(error_code); }
int vrpn_Nikon_Controls::get_report(void) { int ret; // Return value from function call to be checked //-------------------------------------------------------------------- // If we're SYNCing, then the next character we get should be the start // of a report. If we recognize it, go into READing mode and tell how // many characters we expect total. If we don't recognize it, then we // must have misinterpreted a command or something; reset // and start over //-------------------------------------------------------------------- if (status == STATUS_SYNCING) { // Try to get a character. If none, just return. if (vrpn_read_available_characters(serial_fd, _buffer, 1) != 1) { return 0; } // See if we recognize the character as one of the ones making // up a report. If not, then we need to continue syncing. if (strchr(VALID_REPORT_CHARS, _buffer[0]) == NULL) { VRPN_MSG_WARNING("Syncing"); return 0; } // Got the first character of a report -- go into READING mode // and record that we got one character at this time. The next // bit of code will attempt to read the rest of the report. // The time stored here is as close as possible to when the // report was generated. _bufcount = 1; vrpn_gettimeofday(×tamp, NULL); status = STATUS_READING; #ifdef VERBOSE2 printf("... Got the 1st char\n"); #endif } //-------------------------------------------------------------------- // Read a character at a time from the serial port, storing them // in the buffer. Do this until we either run out of characters to // read or else find [CR][LF] along the way, which indicates the end // of a command. //-------------------------------------------------------------------- do { ret = vrpn_read_available_characters(serial_fd, &_buffer[_bufcount], 1); if (ret == -1) { VRPN_MSG_ERROR("Error reading"); status = STATUS_RESETTING; return 0; } _bufcount += ret; #ifdef VERBOSE2 if (ret != 0) printf("... got %d characters (%d total)\n",ret, _bufcount); #endif // See if the last characters in the buffer are [CR][LF]. If so, then // we have a full report so null-terminate and go ahead and parse if ( (_bufcount > 2) && (_buffer[_bufcount-2] == '\r') && (_buffer[_bufcount-1] == '\n') ) { _buffer[_bufcount] = '\0'; break; } // If we have a full buffer, then we've gotten into a bad way. if (_bufcount >= sizeof(_buffer) - 1) { VRPN_MSG_ERROR("Buffer full when reading"); status = STATUS_RESETTING; return 0; } } while (ret != 0); if (ret == 0) { return 0; } //-------------------------------------------------------------------- // We now have enough characters to make a full report. Check it by // trying to parse it. If it is not valid, then we return to // synch mode and ignore this report. A well-formed report has // on of VALID_REPORT_CHARS as its command. We expect these responses // either set the response position (due to a query) or to be valid // but not set the response position (due to a position move request, // for which we store the requested position into the value). //-------------------------------------------------------------------- double response_pos; ret = parse_focus_position_response((const char *)_buffer, response_pos); if (ret <= 0) { fprintf(stderr,"Bad response from nikon [%s], syncing\n", _buffer); fprintf(stderr," (%s)\n", error_code_to_string((int)response_pos)); status = STATUS_SYNCING; return 0; } // Type 3 returns mean "in progress" for some function. Ignore this // report. if (ret == 3) { status = STATUS_SYNCING; _bufcount = 0; return 1; } // Type 2 means that the command we issued before has completed -- put // the value we requested for the focus into the response since that is // where we are now. if (ret == 2) { // We must have gotten where we are going. response_pos = _requested_focus; } //-------------------------------------------------------------------- // Done with the decoding, send the reports and go back to syncing //-------------------------------------------------------------------- channel[0] = response_pos; report_changes(); status = STATUS_SYNCING; _bufcount = 0; return 1; }