Changeset 7812 for trunk/legacy/jvmlink


Ignore:
Timestamp:
11/24/11 14:45:29 (8 years ago)
Author:
mario
Message:

added minimal changes to compile on a POSIX like OS (mainly Linux)

Location:
trunk/legacy/jvmlink/src/main/c++
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/legacy/jvmlink/src/main/c++/JVMLinkClient.cpp

    r3834 r7812  
    3131*/ 
    3232 
     33#ifdef _WIN32 
    3334#include "stdafx.h" 
     35#include <windows.h> 
     36#else 
     37#include <sys/types.h> 
     38#include <sys/wait.h> 
     39#include <sys/socket.h> 
     40#include <unistd.h> 
     41#include <netdb.h> 
     42#endif 
     43 
    3444#include "JVMLinkClient.h" 
    35 #include <Windows.h> 
     45 
     46#include <iostream> 
     47#include <string> 
     48#include <string.h> 
     49#include <sstream> 
     50#include <stdlib.h> 
    3651 
    3752#define DEFAULT_PORT 20345 
     
    4964// -- Public API methods -- 
    5065 
    51 void JVMLinkClient::startJava(int arg_port, CString classpath) { 
    52         port = arg_port == NULL ? DEFAULT_PORT : arg_port; 
    53         CString command; 
     66void JVMLinkClient::startJava(int arg_port, std::string classpath) { 
     67        port = arg_port == 0 ? DEFAULT_PORT : arg_port; 
     68        std::stringstream tmpportstr; 
     69        tmpportstr << port; 
     70        const std::string portstr = tmpportstr.str(); 
     71 
     72#ifdef _WIN32 
    5473        // NB: Toggle comments to control debugging output for the server. 
    55         command.Format("-cp %s loci.jvmlink.JVMLinkServer %d", classpath, port); 
    56         //command.Format("-cp %s loci.jvmlink.JVMLinkServer -debug %d", classpath, port); 
     74        const std::string command = "-cp " + classpath + " loci.jvmlink.JVMLinkServer " + portstr; 
     75        //const std::string command = "-cp " + classpath + " loci.jvmlink.JVMLinkServer -debug " + portstr; 
    5776        debug("java " << command); 
    5877        ShellExecute(NULL, "open", "javaw.exe" , command, "", SW_SHOW); 
    5978        //ShellExecute(NULL, "open", "java.exe" , command, "", SW_SHOW); 
     79#else 
     80        pid_t vProcID = vfork(); 
     81        if (vProcID == 0) { 
     82                // executed by child process 
     83                execlp("java", "java", "-cp", classpath.c_str(), "loci.jvmlink.JVMLinkServer", portstr.c_str(), "-debug", (char*)NULL); 
     84                //execlp("java", "java", "-cp", classpath.c_str(), "loci.jvmlink.JVMLinkServer", portstr.c_str(), (char*)NULL); 
     85 
     86                std::cerr << "Error: Child failed to execute process." << std::endl; 
     87                _exit(1); 
     88        } else if (vProcID < 0) { 
     89                // failed to fork 
     90                debug("Error: Failed to fork, will exit now."); 
     91                exit(1); 
     92        } else { 
     93                // Code only executed by parent process 
     94                // TODO: check if the forked child is alive and working 
     95        } 
     96#endif 
    6097} 
    6198 
     
    66103 
    67104JVMLinkClient::ConnectionCode JVMLinkClient::establishConnection() { 
     105        const std::string servername = "127.0.0.1"; 
     106 
     107#ifdef _WIN32 
    68108        WSADATA wsaData; 
    69109        struct hostent *hp; 
    70110        unsigned int addr; 
    71111        struct sockaddr_in server; 
    72         CString servername = "127.0.0.1";  
    73112 
    74113        int wsaret=WSAStartup(0x101,&wsaData); 
     
    100139                closesocket(conn); 
    101140                debug("No server response on port " << port); 
    102                 return RESPONSE_ERR;     
    103         } 
     141                return RESPONSE_ERR; 
     142        } 
     143#else 
     144        debug("starting to create socket"); 
     145        struct addrinfo hints; 
     146        struct addrinfo *res; 
     147 
     148        memset(&hints, 0, sizeof hints); 
     149        hints.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever 
     150        hints.ai_socktype = SOCK_STREAM; 
     151        hints.ai_flags = AI_PASSIVE;  // fill in my IP for me 
     152 
     153        // do the lookup 
     154        std::stringstream tmpportstr; 
     155        tmpportstr << port; 
     156        const std::string portstr = tmpportstr.str(); 
     157        getaddrinfo(servername.c_str(), portstr.c_str(), &hints, &res); 
     158 
     159        // TODO: should do error-checking on getaddrinfo(), and walk 
     160        // the "res" linked list looking for valid entries instead of just 
     161        // assuming the first one is good 
     162        conn = socket(res->ai_family, res->ai_socktype, res->ai_protocol); 
     163        if (conn < 0) return SOCKET_ERR; 
     164 
     165        debug("finished to create socket"); 
     166 
     167        if (connect(conn, res->ai_addr, res->ai_addrlen) < 0) { 
     168                close(conn); 
     169                debug("No server response on port " << port); 
     170                return RESPONSE_ERR; 
     171        } 
     172#endif 
     173 
    104174        debug("Connected to server: " << servername); 
    105175        return CONNECTION_SUCCESS; 
     
    108178int JVMLinkClient::closeConnection() { 
    109179        debug("Closing connection"); 
     180#ifdef _WIN32 
    110181        shutdown(conn, SD_SEND); 
    111182        closesocket(conn); 
     
    113184        WSACleanup(); 
    114185        debug("De-initialized WinSock"); 
     186#else 
     187        close(conn); 
     188        conn = 0; 
     189#endif 
    115190        return CONNECTION_SUCCESS; 
    116191} 
    117192 
    118 JVMLinkObject* JVMLinkClient::getVar(CString name) { 
     193JVMLinkObject* JVMLinkClient::getVar(std::string name) { 
    119194        debug("getVar: requesting " << name); 
    120195        JVMLinkObject* obj = new JVMLinkObject(name); 
     
    126201                obj->length = readInt(); 
    127202                if (obj->insideType == STRING_TYPE) { 
    128                         CString* s = new CString[obj->length]; 
     203                        std::string* s = new std::string[obj->length]; 
    129204                        for (int i=0; i<obj->length; i++) s[i] = *readString(); 
    130205                        obj->data = s; 
     
    136211                debug("getVar: got array: length=" << obj->length << ", type=" << obj->insideType); 
    137212        } 
    138         else if (obj->type == STRING_TYPE) {     
     213        else if (obj->type == STRING_TYPE) { 
    139214                obj->data = readString(); 
    140215                obj->size = 0; 
     
    156231} 
    157232 
    158 void JVMLinkClient::exec(CString command) { 
     233void JVMLinkClient::exec(std::string command) { 
    159234        debug("exec: " << command); 
    160235        sendInt(EXEC_CMD); 
     
    170245                sendInt(obj->length); 
    171246                if (obj->insideType == STRING_TYPE) { 
    172                         CString* s = (CString*) obj->data; 
     247                        std::string* s = (std::string*) obj->data; 
    173248                        for (int i=0; i<obj->length; i++) { 
    174249                                sendMessage(s[i]); 
     
    185260        } 
    186261        else { 
    187                 if (obj->type == STRING_TYPE) sendMessage(*(CString*) obj->data); 
     262                if (obj->type == STRING_TYPE) sendMessage(*(std::string*) obj->data); 
    188263                else send(conn, (char*) obj->data, obj->size, 0); 
    189264        } 
    190265} 
    191266 
    192 void JVMLinkClient::setVar(CString argname, int obj) { 
     267void JVMLinkClient::setVar(std::string argname, int obj) { 
    193268        debug("setVar: " << argname << " = " << obj << " (int)"); 
    194269        JVMLinkObject* jvmObj = new JVMLinkObject(argname, INT_TYPE, &obj); 
     
    197272} 
    198273 
    199 void JVMLinkClient::setVar(CString argname, int* obj, int length) { 
     274void JVMLinkClient::setVar(std::string argname, int* obj, int length) { 
    200275        debug("setVar: " << argname << " (int array)"); 
    201276        JVMLinkObject* jvmObj = new JVMLinkObject(argname, INT_TYPE, length, obj); 
     
    204279} 
    205280 
    206 void JVMLinkClient::setVar(CString argname, CString* obj) { 
     281void JVMLinkClient::setVar(std::string argname, std::string* obj) { 
    207282        debug("setVar: " << argname << " = " << obj << " (string)"); 
    208283        JVMLinkObject* jvmObj = new JVMLinkObject(argname, STRING_TYPE, obj); 
     
    211286} 
    212287 
    213 void JVMLinkClient::setVar(CString argname, CString* obj, int length) { 
     288void JVMLinkClient::setVar(std::string argname, std::string* obj, int length) { 
    214289        debug("setVar: " << argname << " (string array)"); 
    215290        JVMLinkObject* jvmObj = new JVMLinkObject(argname, STRING_TYPE, length, obj); 
     
    218293} 
    219294 
    220 void JVMLinkClient::setVar(CString argname, char obj) { 
     295void JVMLinkClient::setVar(std::string argname, char obj) { 
    221296        debug("setVar: " << argname << " = " << obj << " (char)"); 
    222297        JVMLinkObject* jvmObj = new JVMLinkObject(argname, CHAR_TYPE, &obj); 
     
    225300} 
    226301 
    227 void JVMLinkClient::setVar(CString argname, char* obj, int length) { 
     302void JVMLinkClient::setVar(std::string argname, char* obj, int length) { 
    228303        debug("setVar: " << argname << " (char array)"); 
    229304        JVMLinkObject* jvmObj = new JVMLinkObject(argname, CHAR_TYPE, length, obj); 
     
    232307} 
    233308 
    234 void JVMLinkClient::setVar(CString argname, Byte obj) { 
     309void JVMLinkClient::setVar(std::string argname, Byte obj) { 
    235310        debug("setVar: " << argname << " = " << obj.data << " (byte)"); 
    236311        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BYTE_TYPE, &obj); 
     
    239314} 
    240315 
    241 void JVMLinkClient::setVar(CString argname, Byte* obj, int length) { 
     316void JVMLinkClient::setVar(std::string argname, Byte* obj, int length) { 
    242317        debug("setVar: " << argname << " (byte array)"); 
    243318        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BYTE_TYPE, length, obj); 
     
    246321} 
    247322 
    248 void JVMLinkClient::setVar(CString argname, float obj) { 
     323void JVMLinkClient::setVar(std::string argname, float obj) { 
    249324        debug("setVar: " << argname << " = " << obj << " (float)"); 
    250325        JVMLinkObject* jvmObj = new JVMLinkObject(argname, FLOAT_TYPE, &obj); 
     
    253328} 
    254329 
    255 void JVMLinkClient::setVar(CString argname, float* obj, int length) { 
     330void JVMLinkClient::setVar(std::string argname, float* obj, int length) { 
    256331        debug("setVar: " << argname << " (float array)"); 
    257332        JVMLinkObject* jvmObj = new JVMLinkObject(argname, FLOAT_TYPE, length, obj); 
     
    260335} 
    261336 
    262 void JVMLinkClient::setVar(CString argname, bool obj) { 
     337void JVMLinkClient::setVar(std::string argname, bool obj) { 
    263338        debug("setVar: " << argname << " = " << obj << " (bool)"); 
    264339        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BOOL_TYPE, &obj); 
     
    267342} 
    268343 
    269 void JVMLinkClient::setVar(CString argname, bool* obj, int length) { 
     344void JVMLinkClient::setVar(std::string argname, bool* obj, int length) { 
    270345        debug("setVar: " << argname << " (bool array)"); 
    271346        JVMLinkObject* jvmObj = new JVMLinkObject(argname, BOOL_TYPE, length, obj); 
     
    274349} 
    275350 
    276 void JVMLinkClient::setVar(CString argname, double obj) { 
     351void JVMLinkClient::setVar(std::string argname, double obj) { 
    277352        debug("setVar: " << argname << " = " << obj << " (double)"); 
    278353        JVMLinkObject* jvmObj = new JVMLinkObject(argname, DOUBLE_TYPE, &obj); 
     
    281356} 
    282357 
    283 void JVMLinkClient::setVar(CString argname, double* obj, int length) { 
     358void JVMLinkClient::setVar(std::string argname, double* obj, int length) { 
    284359        debug("setVar: " << argname << " (double array)"); 
    285360        JVMLinkObject* jvmObj = new JVMLinkObject(argname, DOUBLE_TYPE, length, obj); 
     
    288363} 
    289364 
    290 void JVMLinkClient::setVar(CString argname, long long obj) { 
     365void JVMLinkClient::setVar(std::string argname, long long obj) { 
    291366        debug("setVar: " << argname << " = " << obj << " (long)"); 
    292367        JVMLinkObject* jvmObj = new JVMLinkObject(argname, LONG_TYPE, &obj); 
     
    295370} 
    296371 
    297 void JVMLinkClient::setVar(CString argname, long long* obj, int length) { 
     372void JVMLinkClient::setVar(std::string argname, long long* obj, int length) { 
    298373        debug("setVar: " << argname << " (long array)"); 
    299374        JVMLinkObject* jvmObj = new JVMLinkObject(argname, LONG_TYPE, length, obj); 
     
    302377} 
    303378 
    304 void JVMLinkClient::setVar(CString argname, short obj) { 
     379void JVMLinkClient::setVar(std::string argname, short obj) { 
    305380        debug("setVar: " << argname << " = " << obj << " (short)"); 
    306381        JVMLinkObject* jvmObj = new JVMLinkObject(argname, SHORT_TYPE, &obj); 
     
    309384} 
    310385 
    311 void JVMLinkClient::setVar(CString argname, short* obj, int length) { 
     386void JVMLinkClient::setVar(std::string argname, short* obj, int length) { 
    312387        debug("setVar: " << argname << " (short array)"); 
    313388        JVMLinkObject* jvmObj = new JVMLinkObject(argname, SHORT_TYPE, length, obj); 
     
    316391} 
    317392 
    318 void JVMLinkClient::setVarNull(CString argname) { 
     393void JVMLinkClient::setVarNull(std::string argname) { 
    319394        debug("setVarNull: " << argname); 
    320395        JVMLinkObject* jvmObj = new JVMLinkObject(argname, NULL_TYPE, NULL); 
    321396        setVar(jvmObj); 
    322         delete jvmObj;   
     397        delete jvmObj; 
    323398} 
    324399 
    325400// -- Private methods -- 
    326401 
    327 void JVMLinkClient::sendMessage(CString message) { 
     402void JVMLinkClient::sendMessage(std::string message) { 
    328403        int sent = 0; 
    329         char* buf = (char*) (LPCTSTR) message; 
    330         int total = message.GetLength(); 
     404        const char* buf = message.c_str(); 
     405        int total = message.length(); 
    331406        sendInt(total); 
    332407        while (sent < total) sent += send(conn, buf + sent, total - sent, 0); 
     
    349424} 
    350425 
    351 CString* JVMLinkClient::readString() { 
     426std::string* JVMLinkClient::readString() { 
    352427        int read = 0; 
    353428        int total = readInt(); 
     
    355430        while (read < total) read += recv(conn, buf + read, total - read, 0); 
    356431        buf[total] = '\0'; 
    357         return new CString(buf); 
    358 } 
     432        return new std::string(buf); 
     433} 
  • trunk/legacy/jvmlink/src/main/c++/JVMLinkClient.h

    r3834 r7812  
    3434#include "JVMLinkObject.h" 
    3535 
     36#include <string> 
     37 
    3638// NB: Toggle comments to control debugging output for the client. 
    3739#define debug(msg) ((void)0) 
     
    4244private: 
    4345        int port; 
     46#ifdef _WIN32 
    4447        SOCKET conn; 
     48#else 
     49        int conn; 
     50#endif 
    4551 
    46         void sendMessage(CString); 
     52        void sendMessage(std::string); 
    4753        void* readMessage(int); 
    4854        void sendInt(int); 
    4955        int readInt(); 
    50         CString* readString(); 
     56        std::string* readString(); 
    5157 
    5258public: 
     
    6066 
    6167        JVMLinkClient(); 
    62         void startJava(int, CString); 
     68        void startJava(int, std::string); 
    6369        void shutJava(); 
    6470        ConnectionCode establishConnection(); 
    6571        int closeConnection(); 
    66         JVMLinkObject* getVar(CString); 
     72        JVMLinkObject* getVar(std::string); 
    6773        void setVar(JVMLinkObject*); 
    68         void setVar(CString, int); 
    69         void setVar(CString, int*, int); 
    70         void setVar(CString, CString*); 
    71         void setVar(CString, CString*, int); 
    72         void setVar(CString, char); 
    73         void setVar(CString, char*, int); 
    74         void setVar(CString, Byte); 
    75         void setVar(CString, Byte*, int); 
    76         void setVar(CString, float); 
    77         void setVar(CString, float*, int); 
    78         void setVar(CString, bool); 
    79         void setVar(CString, bool*, int); 
    80         void setVar(CString, double); 
    81         void setVar(CString, double*, int); 
    82         void setVar(CString, long long); 
    83         void setVar(CString, long long*, int); 
    84         void setVar(CString, short); 
    85         void setVar(CString, short*, int); 
    86         void setVarNull(CString); 
    87         void exec(CString); 
     74        void setVar(std::string, int); 
     75        void setVar(std::string, int*, int); 
     76        void setVar(std::string, std::string*); 
     77        void setVar(std::string, std::string*, int); 
     78        void setVar(std::string, char); 
     79        void setVar(std::string, char*, int); 
     80        void setVar(std::string, Byte); 
     81        void setVar(std::string, Byte*, int); 
     82        void setVar(std::string, float); 
     83        void setVar(std::string, float*, int); 
     84        void setVar(std::string, bool); 
     85        void setVar(std::string, bool*, int); 
     86        void setVar(std::string, double); 
     87        void setVar(std::string, double*, int); 
     88        void setVar(std::string, long long); 
     89        void setVar(std::string, long long*, int); 
     90        void setVar(std::string, short); 
     91        void setVar(std::string, short*, int); 
     92        void setVarNull(std::string); 
     93        void exec(std::string); 
    8894 
    8995        ~JVMLinkClient(void); 
  • trunk/legacy/jvmlink/src/main/c++/JVMLinkObject.cpp

    r3834 r7812  
    3434#include "JVMLinkObject.h" 
    3535 
    36 JVMLinkObject::JVMLinkObject(CString name) { 
     36JVMLinkObject::JVMLinkObject(std::string name) { 
    3737        this->name = name; 
    3838} 
    3939 
    4040// Constructor for single primitives 
    41 JVMLinkObject::JVMLinkObject(CString name, Type type, void* data) { 
     41JVMLinkObject::JVMLinkObject(std::string name, Type type, void* data) { 
    4242        this->name = name; 
    4343        this->size = getSize(type); 
     
    4848 
    4949// Constructor for arrays 
    50 JVMLinkObject::JVMLinkObject(CString name, Type type, int length, void* data) { 
     50JVMLinkObject::JVMLinkObject(std::string name, Type type, int length, void* data) { 
    5151        this->name = name; 
    5252        this->size = getSize(type); 
     
    7272} 
    7373 
    74 CString* JVMLinkObject::getDataAsString() { 
    75         CString* retval = (CString*) data; 
     74std::string* JVMLinkObject::getDataAsString() { 
     75        std::string* retval = (std::string*) data; 
    7676        return retval; 
    7777} 
    7878 
    79 CString* JVMLinkObject::getDataAsStringArray() { 
    80         CString* retval = (CString*) data; 
     79std::string* JVMLinkObject::getDataAsStringArray() { 
     80        std::string* retval = (std::string*) data; 
    8181        return retval; 
    8282} 
  • trunk/legacy/jvmlink/src/main/c++/JVMLinkObject.h

    r3834 r7812  
    3333#pragma once 
    3434 
     35#include <string> 
     36#include <vector> 
     37 
     38 
    3539enum Command { 
    3640        BYTE_ORDER_CMD = 0, 
     
    6468 
    6569public: 
    66         JVMLinkObject(CString); 
    67         JVMLinkObject(CString, Type, void*); 
    68         JVMLinkObject(CString, Type, int, void*); 
     70        JVMLinkObject(std::string); 
     71        JVMLinkObject(std::string, Type, void*); 
     72        JVMLinkObject(std::string, Type, int, void*); 
    6973 
    7074        ~JVMLinkObject(void); 
    7175 
    72         CString name; 
     76        std::string name; 
    7377        int size, length; 
    7478        Type type, insideType; 
     
    7781        int getDataAsInt(); 
    7882        int* getDataAsIntArray(); 
    79         CString* getDataAsString(); 
    80         CString* getDataAsStringArray(); 
     83        std::string* getDataAsString(); 
     84        std::string* getDataAsStringArray(); 
    8185        char getDataAsChar(); 
    8286        char* getDataAsCharArray(); 
  • trunk/legacy/jvmlink/src/main/c++/TestC2.cpp

    r3834 r7812  
    3131*/ 
    3232 
    33 #include "stdafx.h" 
     33#ifdef _WIN32 
     34#include <stdafx.h> 
     35#else 
     36#include <unistd.h> // for usleep() 
     37#endif 
     38 
    3439#include "JVMLinkClient.h" 
     40 
    3541#include <ctime> // for time() 
    3642#include <cstdlib> // for srand() and rand() 
     43#include <iostream> // for cout and cerr 
     44#include <stdio.h> // for getchar 
    3745 
    3846bool randomBool() { 
     
    95103} 
    96104 
    97 void printStrings(CString* values, int len) { 
     105void printStrings(std::string* values, int len) { 
    98106        for (int i=0; i<len; i++) { 
    99107                std::cout << "\t" << values[i] << std::endl; 
     
    102110 
    103111// Tests the JVMLink API. 
    104 int _tmain(int argc, _TCHAR* argv[]) 
     112int main(int argc, char* argv[]) 
    105113{ 
    106114        JVMLinkClient *p = new JVMLinkClient(); 
    107115        p->startJava(20345, "jvmlink.jar"); 
    108         while (p->establishConnection() != JVMLinkClient::CONNECTION_SUCCESS) Sleep(250); 
     116        while (p->establishConnection() != JVMLinkClient::CONNECTION_SUCCESS) { 
     117#ifdef _WIN32 
     118                Sleep(250); 
     119#else 
     120                usleep(250 * 1000); 
     121#endif 
     122        } 
    109123 
    110124        srand((int) time(0)); 
     
    167181        std::cout << "TestC2: getVar: myShort == " << jvmShort->getDataAsShort() << std::endl; 
    168182 
    169         // CString variables 
    170         CString myString = "<<The quick brown fox jumps over the lazy dog.>>"; 
     183        // std::string variables 
     184        std::string myString = "<<The quick brown fox jumps over the lazy dog.>>"; 
    171185        p->setVar("myString", &myString); 
    172186        std::cout << "TestC2: setVar: myString -> " << myString << std::endl; 
     
    208222        } 
    209223 
    210         CString* myStrings = new CString[6]; 
     224        std::string* myStrings = new std::string[6]; 
    211225        myStrings[0] = "\"There was an Old Man with a beard,"; 
    212226        myStrings[1] = "Who said, 'It is just as I feared!"; 
     
    296310        std::cout << " ]" << std::endl; 
    297311 
    298         // CString arrays 
     312        // std::string arrays 
    299313        p->setVar("myStrings", myStrings, 6); 
    300314        std::cout << "TestC2: setVar: myStrings -> [" << std::endl; 
     
    358372        delete largeBytes; 
    359373 
    360         fprintf(stdout, "\n\nPress enter to shut down the server and exit...\n"); 
     374        std::cout << std::endl << std::endl << "Press enter to shut down the server and exit..." << std::endl; 
     375#ifdef _WIN32 
    361376        _fgetchar(); 
     377#else 
     378        getchar(); 
     379#endif 
    362380 
    363381        // free Java resources 
  • trunk/legacy/jvmlink/src/main/c++/stdafx.h

    r3685 r7812  
    33//      are changed infrequently 
    44// 
     5 
     6// this header is required for Windows only 
     7#ifdef _WIN32 
    58 
    69#if !defined(AFX_STDAFX_H__59F83989_2D03_11D6_AA7C_00C026A39668__INCLUDED_) 
     
    3033 
    3134#endif // !defined(AFX_STDAFX_H__59F83989_2D03_11D6_AA7C_00C026A39668__INCLUDED_) 
     35 
     36#endif // _WIN32 
Note: See TracChangeset for help on using the changeset viewer.