---

main.cpp

Go to the documentation of this file.

/*
 * This file is part of Jelie,
 * (c) 2002 Julien Pilet <julien.pilet@epfl.ch> and
 * Stephane Magnenat <stephane.magnenat@epfl.ch>
 *
 * Jelie is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Jelie is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Foobar; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <unistd.h>
#include <signal.h>

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef HAVE_LIBREADLINE
#include <readline/readline.h>
#include <readline/history.h>
#endif

#include "gdbremote.h"
#include "jtagpxa250.h"
#include "cmdline.h"
#include "filemanager.h"
#include "debug.h"
#include "jtagctrl_factory.h"

class EventSelector {
private:
        CmdLine cmd;

        GdbRemote gdbRemote;
        int tcpPort;    //< tcp port to listen to GDB.

        bool withReadLine;

        int commandResult;

public:
        EventSelector(int tcpPort);

        static void handleInputCommand(char *buffer);

        void read_char();

        void loop();
};

EventSelector *event;

#ifdef HAVE_LIBREADLINE
void set_prompt_and_display(void)
{
        if (pxa250Ptr->targetReady())
                rl_set_prompt("r> ");
        else
                rl_set_prompt("n> ");
        rl_redisplay();
}
#endif

EventSelector::EventSelector(int tcpPort) : gdbRemote(pxa250Ptr), 
        tcpPort(tcpPort), commandResult(0) 
{
#ifdef HAVE_LIBREADLINE
        if (isatty(fileno(stdin))) {
                // we have a human on stdin. Let's use libreadline.
                if (pxa250Ptr->targetReady())
                        rl_callback_handler_install("r> ", handleInputCommand);
                else
                        rl_callback_handler_install("n> ", handleInputCommand);

                rl_redisplay_function = set_prompt_and_display;
                withReadLine = true;
        } else {
                withReadLine = false;
        }
#else
        withReadLine = false;
#endif
}
        
void EventSelector::loop() {

        // open the TCP port to listen to GDB.
        if (!gdbRemote.openPort(tcpPort)) {
                gdbRemote.printError();
        }

        // loop, waiting for user input and polling the debug handler, 
        // in case it has something to say.
        do {
                fd_set fds;
                struct timeval timeout;
                int max;
                
                FD_ZERO(&fds);
                max = gdbRemote.prepareFD_SET(&fds);
                FD_SET(fileno(stdin), &fds);
                if (fileno(stdin) > max) max = fileno(stdin);
                
                // set the timeout
                timeout.tv_sec = 0;
                timeout.tv_usec = 100; // polling 10 times a second should be ok

                if (select(max + 1, &fds, 0, 0, &timeout) == 0) {
                        // timeout has occured, polls the TX register
                        pxa250Ptr->pollForTX();
                } 

                gdbRemote.processFD_SET(&fds);

                if (FD_ISSET(fileno(stdin), &fds)) {
#ifdef HAVE_LIBREADLINE
                        if (withReadLine)
                                rl_callback_read_char();
                        else
#endif
                                read_char();
                }
        } while (commandResult != -1);
}

#define MAX_BUFF_SIZE 256
void EventSelector::read_char() {
        static char *buffer = 0;
        static int pos;

        if (buffer == 0) {
                buffer = (char *) malloc(MAX_BUFF_SIZE);
                buffer[0]=0;
                pos = 0;
        }
        
        assert(pos < MAX_BUFF_SIZE);

        if (read(fileno(stdin), buffer + pos, 1) <= 0) {
                pos = 0;
                usleep(10);
                return;
        }
        
        if (buffer[pos] == '\n') {
                if (pos) {
                        buffer[pos] = 0;

                        // we got a non empty line
                        handleInputCommand(buffer);
                        buffer = 0;
                }
        } else {
                pos++;
        }
}
        
void EventSelector::handleInputCommand(char *buffer) {
        if (!buffer || !buffer[0])
                return;
#ifdef HAVE_LIBREADLINE
        add_history(buffer);
#endif

        // before executing a command, make sure the debug handler
        // has nothing to say.
        pxa250Ptr->pollForTX();

        event->commandResult = event->cmd.exec(buffer);
        //if (result != 0 && result != -1)
        if (event->commandResult == 0)
                printf("[ok]\n");
        else
                printf("[return code %d]\n", event->commandResult);

        free(buffer);
        
        // we might already have an answer
        pxa250Ptr->pollForTX();
}

void usage(const char *prog) {
        fprintf(stderr, "usage:\n"
                        "%s [-h] [-p] [-d] [-I <dir>] [-t <tcp port>]\n"
                        "-h             prints this help\n"
                        "-p             use parallel port (Wiggler)\n"
                        "-d             enable debugging\n"
                        "-I <dir>       look also in <dir> when searching a file\n"
                        "-t <tcp port>  listent to <tcp port> instead of %d\n",
                        prog, GDB_REMOTE_DEFAULT_PORT);
        exit(-1);
}

int main(int argc, char *argv[]) {

        printf("This is " PACKAGE " version " VERSION "\n");
        printf("Julien Pilet & Stephane Magnenat, 6.2002 - 3.2003.\n");

        bool usePP=false;
        int tcpPort = GDB_REMOTE_DEFAULT_PORT;

        // construct the file handling system
        fileManagerPtr = new FileManager();

        // check for a '-d' option
        for (int i=1; i<argc; i++) {
                if (argv[i][0] == '-') {
                        switch (argv[i][1]) {
                                case 'd': 
                                        addDebugLevel(CMD_SCRIPT_DEBUG);
                                        addDebugLevel(GDB_REMOTE_DEBUG);
                                        break;
                                case 'p': 
                                        usePP = true; break;
                                case 'I': 
                                        ++i; 
                                        if (i  < argc) 
                                                fileManagerPtr->addDir(argv[i]);
                                        else
                                                usage(argv[0]);
                                        break;
                                case 't': 
                                        ++i; 
                                        if (i< argc) 
                                                tcpPort = atoi(argv[i]); 
                                        else
                                                usage(argv[0]);
                                        break;
                                case 'h': 
                                default:
                                        usage(argv[0]);
                        }
                }
        }

        // contruct the control object
        JTAGControl *jtag=NULL;
        JTAGControlFactory factory;
        const char *ctlName=NULL;

        if (usePP) {
                ctlName="pp";
        } else {
                ctlName="ezusb";
        }
        jtag = factory.getPrefered(ctlName, argc, argv);
        if (!jtag)
        {
                fprintf(stderr, "Can't get prefered JTAG control %s, " 
                                "trying another one\n", ctlName);
                jtag = factory.getAvailable(argc, argv);
        }
        if (!jtag)
        {
                fprintf(stderr, "Can't find any JTAG control, critical stop !\n");
                exit(-1);
        }

        printf("JTAG control %s used\n", jtag->getName());
        JTAGpxa250 pxa(jtag);

        pxa250Ptr = &pxa;

        pxa.loadDebugHandler();
        event = new EventSelector(tcpPort);

        event->loop();
        delete event;
        delete fileManagerPtr;
}

---