void check_exit(const LineInfo& line_info, bool expression, const CStringView error_message)
{
if (!expression)
{
exit_with_message(line_info, error_message);
}
}
int main(int argc, char **argv)
{
Prover_input input;
int return_code;
print_banner(argc, argv, PROVER_NAME, PROGRAM_VERSION, PROGRAM_DATE, FALSE);
/***************** Initialize and read the input ***************************/
input = std_prover_init_and_input(argc, argv,
FALSE, // don't clausify
TRUE, // echo input to stdout
KILL_UNKNOWN); // unknown flags/parms are fatal
if (input->usable || input->demods)
fatal_error(PROVER_NAME ": all input clauses must be in sos, assumptions, "
"or goals list");
/***************** Search for a proof **************************************/
if (flag(input->options->auto_denials)) {
clear_flag(input->options->auto_denials, TRUE);
printf("\n%% clear(auto_denials), because it is incompatiable with "
"FOF reduction.\n");
}
/***************** Search for a proof **************************************/
return_code = foffer(input);
/***************** Print result message and exit ***************************/
if (return_code == MAX_PROOFS_EXIT) {
printf("\nTHEOREM PROVED\n");
if (!flag(input->options->quiet))
fprintf(stderr, "\nTHEOREM PROVED\n");
}
else {
printf("\nSEARCH FAILED\n");
if (!flag(input->options->quiet))
fprintf(stderr, "\nSEARCH FAILED\n");
}
exit_with_message(stdout, return_code);
exit(1); // to satisfy the compiler (won't be called)
} // main
void read_from_dead_disk(int r5_dev ,int offset, int size, int dead_disk_index, int sector_start, int sector_end){
char tempBuffer[BLOCK_SIZE] = {0}, tempRead[BLOCK_SIZE];
int i,j, currDevice;
for(i = 0; i < r5; i++){
currDevice = r5_dev * r5 + i;
if( currDevice == dead_disk_index) continue;
if((offset != lseek(dev_fd[currDevice], offset, SEEK_SET)) || (size != read( dev_fd[currDevice], tempRead, size)))
assert(exit_with_message() && "More devices failed than can be recovered");
else
printf("Operation on device %d, sector %d-%d\n", currDevice, sector_start, sector_end);
for(j = 0 ; j < BLOCK_SIZE ; j++){ //xoring together
tempBuffer[j] = tempBuffer[j] ^ tempRead[j];
}
}
for(j = 0 ; j < BLOCK_SIZE ; j++){ //copying to the buffer
buf[j] = tempBuffer[j];
}
}
int main()
{
int id;
long n;
const PmDeviceInfo *info;
char line[STRING_MAX];
int spin;
int done = FALSE;
/* determine what type of test to run */
printf("begin PortMidi multithread test...\n");
/* note that it is safe to call PortMidi from the main thread for
initialization and opening devices. You should not make any
calls to PortMidi from this thread once the midi thread begins.
to make PortMidi calls.
*/
/* make the message queues */
/* messages can be of any size and any type, but all messages in
* a given queue must have the same size. We'll just use long's
* for our messages in this simple example
*/
midi_to_main = Pm_QueueCreate(32, sizeof(long));
assert(midi_to_main != NULL);
main_to_midi = Pm_QueueCreate(32, sizeof(long));
assert(main_to_midi != NULL);
/* a little test of enqueue and dequeue operations. Ordinarily,
* you would call Pm_Enqueue from one thread and Pm_Dequeue from
* the other. Since the midi thread is not running, this is safe.
*/
n = 1234567890;
Pm_Enqueue(midi_to_main, &n);
n = 987654321;
Pm_Enqueue(midi_to_main, &n);
Pm_Dequeue(midi_to_main, &n);
if (n != 1234567890) {
exit_with_message("Pm_Dequeue produced unexpected result.");
}
Pm_Dequeue(midi_to_main, &n);
if(n != 987654321) {
exit_with_message("Pm_Dequeue produced unexpected result.");
}
/* always start the timer before you start midi */
Pt_Start(1, &process_midi, 0); /* start a timer with millisecond accuracy */
/* the timer will call our function, process_midi() every millisecond */
Pm_Initialize();
id = Pm_GetDefaultOutputDeviceID();
info = Pm_GetDeviceInfo(id);
if (info == NULL) {
printf("Could not open default output device (%d).", id);
exit_with_message("");
}
printf("Opening output device %s %s\n", info->interf, info->name);
/* use zero latency because we want output to be immediate */
Pm_OpenOutput(&midi_out,
id,
DRIVER_INFO,
OUTPUT_BUFFER_SIZE,
TIME_PROC,
TIME_INFO,
LATENCY);
id = Pm_GetDefaultInputDeviceID();
info = Pm_GetDeviceInfo(id);
if (info == NULL) {
printf("Could not open default input device (%d).", id);
exit_with_message("");
}
printf("Opening input device %s %s\n", info->interf, info->name);
Pm_OpenInput(&midi_in,
id,
DRIVER_INFO,
INPUT_BUFFER_SIZE,
TIME_PROC,
TIME_INFO);
active = TRUE; /* enable processing in the midi thread -- yes, this
is a shared variable without synchronization, but
this simple assignment is safe */
printf("Enter midi input; it will be transformed as specified by...\n");
printf("%s\n%s\n%s\n",
"Type 'q' to quit, 'm' to monitor next pitch, t to toggle thru or",
"type a number to specify transposition.",
"Must terminate with [ENTER]");
while (!done) {
long msg;
int len;
fgets(line, STRING_MAX, stdin);
/* remove the newline: */
len = strlen(line);
if (len > 0) line[len - 1] = 0; /* overwrite the newline char */
if (strcmp(line, "q") == 0) {
msg = QUIT_MSG;
Pm_Enqueue(main_to_midi, &msg);
/* wait for acknowlegement */
do {
spin = Pm_Dequeue(midi_to_main, &msg);
} while (spin == 0); /* spin */ ;
done = TRUE; /* leave the command loop and wrap up */
} else if (strcmp(line, "m") == 0) {
msg = MONITOR_MSG;
Pm_Enqueue(main_to_midi, &msg);
printf("Waiting for note...\n");
do {
spin = Pm_Dequeue(midi_to_main, &msg);
} while (spin == 0); /* spin */ ;
printf("... pitch is %ld\n", msg);
} else if (strcmp(line, "t") == 0) {
/* reading midi_thru asynchronously could give incorrect results,
e.g. if you type "t" twice before the midi thread responds to
the first one, but we'll do it this way anyway. Perhaps a more
correct way would be to wait for an acknowledgement message
containing the new state. */
printf("Setting THRU %s\n", (midi_thru ? "off" : "on"));
msg = THRU_MSG;
Pm_Enqueue(main_to_midi, &msg);
} else if (sscanf(line, "%ld", &msg) == 1) {
if (msg >= -127 && msg <= 127) {
/* send transposition value */
printf("Transposing by %ld\n", msg);
Pm_Enqueue(main_to_midi, &msg);
} else {
printf("Transposition must be within -127...127\n");
}
} else {
printf("%s\n%s\n%s\n",
"Type 'q' to quit, 'm' to monitor next pitch, or",
"type a number to specify transposition.",
"Must terminate with [ENTER]");
}
}
/* at this point, midi thread is inactive and we need to shut down
* the midi input and output
*/
Pt_Stop(); /* stop the timer */
Pm_QueueDestroy(midi_to_main);
Pm_QueueDestroy(main_to_midi);
/* Belinda! if close fails here, some memory is deleted, right??? */
Pm_Close(midi_in);
Pm_Close(midi_out);
printf("finished portMidi multithread test...enter any character to quit [RETURN]...");
fgets(line, STRING_MAX, stdin);
return 0;
}
