/**
* Programme principal
*/
int main(){
srand(time(NULL));
checkSignal();
mainMenu(grid);
return 0;
}
int main(int argc, char* argv[], char* envp[])
{
/* Command line args */
if(argc < 2)
{
fprintf( stderr, "Usage:\t%s target [options]\n", argv[0] );
return( -1 );
}
char* target = argv[1];
/* Install the signal handler */
checkSignal( signal(SIGHUP, sigHandler));
checkSignal( signal(SIGINT, sigHandler));
checkSignal( signal(SIGQUIT, sigHandler));
checkSignal( signal(SIGTERM, sigHandler));
checkSignal( signal(SIGUSR1, sigHandler));
checkSignal( signal(SIGUSR2, sigHandler));
checkSignal( signal(SIGPIPE, SIG_IGN));
checkSignal( signal(SIGALRM, SIG_IGN));
/* Fork */
if (!(pid = fork()))
{
/* execute */
execve(target, & argv[1], envp);
fprintf( stderr, "Error executing target: %s", target );
return RC_EXEC;
}
/* Wait for the child to exit then return. (Or we exit from signal handler.) */
int status;
wait(&status);
return status;
}
int main(int argc, char** argv)
{
init_sig_handling();
atexit(cleanup);
// Get arguments
long speed = DEFAULT_SPEED;
char *devpath = NULL;
char *filepath = NULL;
int noisy = 1;
int verbose = 0;
int compress = 0;
int interactive = isatty(STDIN_FILENO);
unsigned max_unconfirmed = 0;
{
int opt;
while ((opt = getopt(argc, argv, "h?qvcs:u:f:")) >= 0) {
switch(opt) {
case 's': /* Speed */
speed = strtol(optarg, NULL, 10);
break;
case 'f':
filepath = optarg;
break;
case 'u':
max_unconfirmed = strtol(optarg, NULL, 10);
break;
case 'q': /* Quiet */
noisy = 0;
break;
case 'v': /* Verbose */
verbose = 1;
break;
case 'c':
compress = 1;
break;
case '?': /* Help */
case 'h':
usage(argc, argv);
fprintf(stderr, HELP);
exit(EXIT_SUCCESS);
break;
default:
break;
}
}
switch(argc - optind) {
case 1:
devpath = argv[optind];
break;
case 0:
if(noisy) {
printf("Guessing a likely USB serial device...\n");
}
devpath = guessSerial();
if(devpath == NULL) {
fprintf(stderr, "Unable to autodetect any USB serial devices; if you are certain the device is available, please manually specify the path.\n");
usage(argc, argv);
exit(EXIT_FAILURE);
}
break;
default:
fprintf(stderr, "Too many arguments!\n");
usage(argc, argv);
exit(EXIT_FAILURE);
}
if(filepath == NULL) {
filepath = "-";
}
}
if(noisy) {
printf("Serial device:\t%s\n", devpath);
printf("Line speed:\t%ld\n", speed);
printf("Gcode file:\t%s\n", filepath);
}
/* Open FDs */
serial = serial_open(devpath, speed);
if(serial == NULL) {
fprintf(stderr, "Error opening serial device %s: %s\n", devpath, serial_strerror(serial_errno));
exit(EXIT_FAILURE);
}
if(strncmp("-", filepath, 1) == 0) {
if(noisy) {
printf("Will read gcode from standard input");
if(interactive) {
printf("; enter Ctrl-D (EOF) to finish.");
}
printf("\n");
}
/* input defaults to stdin */
} else {
input = open(filepath, O_RDONLY);
if(input < 0) {
fprintf(stderr, "Unable to open gcode file \"%s\": %s\n", filepath, strerror(errno));
exit(EXIT_FAILURE);
}
interactive = 0;
}
#ifdef UNIX
struct pollfd fds[FD_COUNT];
fds[FD_INPUT].fd = input;
fds[FD_INPUT].events = POLLIN;
fds[FD_SERIAL].fd = serial->handle;
fds[FD_SERIAL].events = POLLIN;
#endif
char serialbuf[SERIAL_BUFSIZE];
char gcodebuf[GCODE_BUFSIZE];
int ret = 0;
int confpoint = 0; /* N chars of CONFIRM_MSG found. */
int startpoint = 0; /* N chars of START_MSG found. */
size_t len;
size_t gcpoint = 0;
int gccomment = 0;
unsigned unconfirmed = 0;
int inputdone = 0;
while(1) {
debug("Polling...");
#ifdef UNIX
if(inputdone) {
if(unconfirmed == 0) {
debug("Last message confirmed, exiting.");
exit(EXIT_SUCCESS);
}
ret = poll(&fds[FD_SERIAL], 1, -1);
} else {
ret = poll(fds, FD_COUNT, -1);
}
#elif WINDOWS
#error TODO: Modify windows code to poll stdin as well as serial.
switch(WaitForMultipleObjects(1, &(serial->handle), FALSE, -1)) {
case WAIT_FAILED:
/* TODO: Get error */
ret = -1;
break;
case WAIT_TIMEOUT:
ret = 0;
break;
case WAIT_OBJECT_0:
ret = 1;
break;
default:
break;
}
#endif
if(ret < 0) {
checkSignal();
fprintf(stderr, "Error during poll: %s\n", strerror(errno));
fprintf(stderr, "Giving up.\n");
exit(EXIT_FAILURE);
}
/* TODO: Windows */
/* FIXME: Why are replies shifted forwards by one? */
if(fds[FD_SERIAL].revents & POLLIN) {
/* We've got reply data! */
debug("Got serial.");
len = serial_read(serial, serialbuf, sizeof(serialbuf)-1);
if(verbose || interactive) {
fwrite(serialbuf, sizeof(char), len, stdout);
fflush(stdout);
}
/* Scan for confirmation message */
int i;
for(i = 0; i < len; i++) {
if(serialbuf[i] == CONFIRM_MSG[confpoint]) {
confpoint++;
if(confpoint >= strlen(CONFIRM_MSG)) {
debug("Message receipt confirmed!");
if(unconfirmed > 0) { /* Sanity check */
unconfirmed--;
}
/* Got confirmation, resume polling for and sending gcode. */
fds[FD_INPUT].events = POLLIN;
/* Clear gcode buffer for next message */
gcpoint = 0;
confpoint = 0;
}
} else {
confpoint = 0;
}
if(serialbuf[i] == START_MSG[startpoint]) {
startpoint++;
if(startpoint >= strlen(START_MSG) && unconfirmed) {
debug("Machine was reset.");
/* Machine just started, and thus hasn't been
* listening, so we have to resend the last block. */
serial_write(serial, gcodebuf, gcpoint);
serial_write(serial, "\r\n", 2);
debug("Resent last block.");
}
} else {
startpoint = 0;
}
}
}
/* TODO: Windows */
/* POLLHUP handles some stdin EOF situations missed by POLLIN */
if(fds[FD_INPUT].revents & POLLIN || fds[FD_INPUT].revents & POLLHUP) {
/* We've got input data! */
int ret;
char ch;
ret = read(fds[FD_INPUT].fd, &ch, 1);
if(ret == 0) {
/* We're at EOF */
debug("Got EOF; input complete.\n");
fds[FD_INPUT].events = 0;
inputdone = 1;
continue;
} else if(ret < 0) {
/* Something went wrong */
checkSignal();
fprintf(stderr, "Error reading gcode: %s\n", strerror(errno));
fprintf(stderr, "Giving up.\n");
exit(EXIT_FAILURE);
}
switch(ch) {
case '\r':
case '\n':
{
gccomment = 0;
if(gcpoint == 0) {
break;
}
serial_write(serial, gcodebuf, gcpoint);
serial_write(serial, "\r\n", 2);
unconfirmed++;
debug("Sent complete block.");
if(verbose && !interactive) {
fwrite(gcodebuf, sizeof(char), gcpoint, stdout);
printf("\n");
}
if(unconfirmed > max_unconfirmed) {
/* Stop polling input until we have some confirmation */
fds[FD_INPUT].events = 0;
}
break;
}
case ';':
if(compress) {
gccomment = 1;
}
case ' ':
case '\t':
if(compress) {
break;
}
default:
if(!gccomment) {
gcodebuf[gcpoint++] = ch;
}
break;
}
}
}
if(noisy) {
printf("Successfully completed!\n");
}
exit(EXIT_SUCCESS);
}
int main()
{
{
// Check the default constructor
EntityRef ref;
}
{
// Check the default constructor initialises to NULL via get
EntityRef ref;
assert(ref.get() == 0);
}
{
// Check the default constructor initialises to NULL via dereference
EntityRef ref;
assert(&(*ref) == 0);
}
{
// Check the default constructor initialises to NULL via ->
EntityRef ref;
assert(ref.operator->() == 0);
}
{
// Check the default constructor initialises to NULL via ==
EntityRef ref;
assert(ref == 0);
}
{
// Check the initialising constructor via get
Entity * e = new Entity("1", 1);
EntityRef ref(e);
assert(ref.get() == e);
}
{
// Check the initialising constructor via dereference
Entity * e = new Entity("1", 1);
EntityRef ref(e);
assert(&(*ref) == e);
}
{
// Check the initialising constructor via ->
Entity * e = new Entity("1", 1);
EntityRef ref(e);
assert(ref.operator->() == e);
}
{
// Check the initialising constructor via ==
Entity * e = new Entity("1", 1);
EntityRef ref(e);
assert(ref == e);
}
{
// Check the copy constructor
Entity * e = new Entity("1", 1);
EntityRef ref(e);
EntityRef ref2(ref);
assert(ref2.get() == e);
}
{
// Check the comparison operator
Entity * e = new Entity("1", 1);
EntityRef ref(e);
EntityRef ref2(e);
assert(ref == ref2);
}
{
// Check the comparison operator
Entity * e = new Entity("1", 1);
Entity * e2 = new Entity("2", 2);
EntityRef ref(e);
EntityRef ref2(e2);
assert(!(ref == ref2));
}
#if 0
// These tests should be included should we add operator!=
{
// Check the comparison operator
Entity e("1", 1);
EntityRef ref(&e);
EntityRef ref2(&e);
assert(!(ref != ref2));
}
{
// Check the comparison operator
Entity e("1", 1);
Entity e2("2", 2);
EntityRef ref(&e);
EntityRef ref2(&e2);
assert(ref != ref2);
}
#endif
{
// Check the less than operator
Entity * e = new Entity("1", 1);
EntityRef ref(e);
EntityRef ref2(e);
assert(!(ref < ref2) && !(ref2 < ref));
}
{
// Check the less than operator
Entity * e = new Entity("1", 1);
Entity * e2 = new Entity("2", 2);
EntityRef ref(e);
EntityRef ref2(e2);
assert(ref < ref2 || ref2 < ref);
}
{
// Check the assignment operator
Entity * e = new Entity("1", 1);
EntityRef ref;
ref = EntityRef(e);
assert(ref.get() == e);
}
{
// Check that destroying the Entity makes the reference null.
Entity e("1", 1);
Entity * container = new Entity("2", 2);
// Set the location of the entity being tested, as destroy requires it.
e.m_location.m_loc = container;
// Make sure the container has a contains structure, as destroy
// requires it.
container->m_contains = new LocatedEntitySet;
// Increment the refcount on the container, else the tested Entity's
// destructor will delete it.
container->incRef();
EntityRef ref(&e);
assert(ref.get() == &e);
e.destroy();
assert(ref.get() == 0);
}
checkSignal();
}
