// Attempt to parse the specified source file and add it to the given AST // @return true on success, false on error static bool parse_source_file(ast_t* package, const char* file_path, pass_opt_t* options) { assert(package != NULL); assert(file_path != NULL); source_t* source = source_open(file_path); if(source == NULL) { errorf(file_path, "couldn't open file %s", file_path); return false; } return module_passes(package, options, source); }
int thread_read_openstream(struct thread_read *thread) { thread->source = new_source(thread->url, thread->headers, thread->flags); if (thread->source != NULL) { int ret; ret = source_open(thread->source); if (ret != 0) { LOGI("source opened failed\n"); release_source(thread->source); thread_read_wakewait(thread); thread->source = NULL; thread->error = ret; return ret; } source_getoptions(thread->source, &thread->options); thread_read_wakewait(thread); thread->opened = 1; } return 0; }
static void *simple_source_thread (void *param) { char *name = (char *) param; int status; char buf [USB_BUFSIZE]; status = source_open (name); if (status < 0) return 0; source_fd = status; pthread_cleanup_push (close_fd, &source_fd); do { unsigned long len; /* original LinuxThreads cancelation didn't work right * so test for it explicitly. */ pthread_testcancel (); len = fill_in_buf (buf, sizeof buf); if (len > 0) status = write (source_fd, buf, len); else status = 0; } while (status > 0); if (status == 0) { if (verbose) fprintf (stderr, "done %s\n", __FUNCTION__); } else if (verbose > 2 || errno != ESHUTDOWN) /* normal disconnect */ perror ("write"); fflush (stdout); fflush (stderr); pthread_cleanup_pop (1); return 0; }
int main(int argc, const char *argv[]) { int result = 0; apr_pool_t *mp; apr_status_t status; char next_char; Source *source = NULL; apr_initialize(); status = apr_pool_create(&mp, NULL); handle_and_display_error(status); source_init(&source, mp); status = source_set_options(source, argc, argv, mp); handle_and_display_error(status); status = source_open(source, mp); handle_and_display_error(status); while (source_shift_character(source, &next_char) == APR_SUCCESS) { printf("%c", next_char); } goto cleanup; error: result = 1; cleanup: if (source) { source_cleanup(source); } apr_pool_destroy(mp); apr_terminate(); return result; }
// Attempt to parse the specified source file and add it to the given AST // @return true on success, false on error static bool parse_source_file(ast_t* package, const char* file_path, pass_opt_t* opt) { pony_assert(package != NULL); pony_assert(file_path != NULL); pony_assert(opt != NULL); if(opt->print_filenames) printf("Opening %s\n", file_path); const char* error_msg = NULL; source_t* source = source_open(file_path, &error_msg); if(source == NULL) { if(error_msg == NULL) error_msg = "couldn't open file"; errorf(opt->check.errors, file_path, "%s %s", error_msg, file_path); return false; } return module_passes(package, opt, source); }
static void *aio_in_thread (void *param) { char *name = (char *) param; int status; io_context_t ctx = 0; struct iocb *queue, *iocb; unsigned i; status = source_open (name); if (status < 0) return 0; source_fd = status; pthread_cleanup_push (close_fd, &source_fd); /* initialize i/o queue */ status = io_setup (aio_in, &ctx); if (status < 0) { perror ("aio_in_thread, io_setup"); return 0; } pthread_cleanup_push (queue_release, &ctx); if (aio_in == 0) aio_in = 1; queue = alloca (aio_in * sizeof *iocb); /* populate and (re)run the queue */ for (i = 0, iocb = queue; i < aio_in; i++, iocb++) { char *buf = malloc (iosize); if (!buf) { fprintf(stderr, "%s can't get buffer[%d]\n", __FUNCTION__, i); return 0; } /* host receives the data we're writing */ io_prep_pwrite (iocb, source_fd, buf, fill_in_buf (buf, iosize), 0); io_set_callback (iocb, in_complete); iocb->key = USB_DIR_IN; status = io_submit (ctx, 1, &iocb); if (status < 0) { perror (__FUNCTION__); break; } aio_in_pending++; if (verbose > 2) fprintf(stderr, "%s submit uiocb %p\n", __FUNCTION__, iocb); } status = io_run (ctx, &aio_in_pending); if (status < 0) perror ("aio_in_thread, io_run"); /* clean up */ fflush (stderr); pthread_cleanup_pop (1); pthread_cleanup_pop (1); return 0; }
/* ccid thread, forwards ccid requests to pcsc and returns results */ static void *ccid (void *param) { char **names = (char **) param; char *source_name = names[0]; char *sink_name = names[1]; int result; size_t bufsize = sizeof(PC_to_RDR_XfrBlock_t) + CCID_EXT_APDU_MAX; __u8 inbuf[bufsize]; source_fd = source_open (source_name); if (source_fd < 0) { if (verbose > 1) perror("source_fd"); goto error; } pthread_cleanup_push (close_fd, &source_fd); sink_fd = sink_open (sink_name); if (sink_fd < 0) { if (verbose > 1) perror("sink_fd"); goto error; } pthread_cleanup_push (close_fd, &sink_fd); pthread_cleanup_push (close_ccid, NULL); __u8 *outbuf = NULL; pthread_cleanup_push (free, outbuf); do { /* original LinuxThreads cancelation didn't work right * so test for it explicitly. */ pthread_testcancel (); if (verbose > 1) fprintf(stderr, "bulk loop: reading %lu bytes... ", (long unsigned) bufsize); result = read(sink_fd, inbuf, bufsize); if (result < 0) break; if (verbose > 1) fprintf(stderr, "bulk loop: got %d, done.\n", result); if (!result) break; result = ccid_parse_bulkout(inbuf, result, &outbuf); if (result < 0) break; if (verbose > 1) fprintf(stderr, "bulk loop: writing %d bytes... ", result); result = write(source_fd, outbuf, result); if (verbose > 1) fprintf(stderr, "done (%d written).\n", result); } while (result >= 0); if (errno != ESHUTDOWN || result < 0) { perror ("ccid loop aborted"); pthread_cancel(ep0); } pthread_cleanup_pop (1); pthread_cleanup_pop (1); pthread_cleanup_pop (1); pthread_cleanup_pop (1); fflush (stdout); fflush (stderr); return 0; error: pthread_cancel(ep0); pthread_exit(0); }
media_source_t* client_open_source(sipua_t* sipua, char* name, char* mode, void* param) { ogmp_client_t *client = (ogmp_client_t*)sipua; return source_open(name, client->control, mode, param); }