rserve-client 0.1.5 → 0.1.6

data/lib/rserve/engine.rb

@@ -14,27 +14,27 @@ module Rserve
       evaluate(p,where,resolve)
     end
     def close;
-      false
+    false
     end
     def supports_references?
-      false
+    false
     end
     def supports_enviroments?
-      false
+    false
     end
     def supports_REPL?
-      false
+    false
     end
     def suuports_locking?
-      false
+    false
     end
     def try_lock
-      0
+    0
     end
     def lock
-      0
+    0
     end
     def unlock;end;
-    
+  
   end
-end
+end

data/lib/rserve/packet.rb

@@ -2,11 +2,11 @@ module Rserve
   class Packet
     attr_reader :cont
     attr_reader :cmd
-    
+
     ERROR_DESCRIPTIONS={
       2=>'Invalid expression',
     127=>'Unknown variable/method'}
-    
+
     def initialize(cmd, cont)
       raise "cont [#{cont.class} - #{cont.to_s}] should respond to :length" if !cont.nil? and !cont.respond_to? :length
       @cmd=cmd

data/lib/rserve/protocol.rb

@@ -1,15 +1,15 @@
 module Rserve
   #
-  # This module encapsulates methods and constants related to QAP1 protocol used by Rserv. Follows almost exactly the interface on RTalk class 
+  # This module encapsulates methods and constants related to QAP1 protocol used by Rserv. Follows almost exactly the interface on RTalk class
   # on Java version, except for use of undescores instead of CamelCase
   # Implementation could differ if a cleaner/faster ruby version is available
-  # 
+  #
   # Policy: No other class should know about the internal of protocol!
   # See Rtalk class on Java version.
   module Protocol
     # Defines from Rsrv.h
     CMD_RESP=0x010000 # all responses have this flag set
-    RESP_OK=(CMD_RESP|0x0001) # command succeeded; returned parameters depend on the command issued 
+    RESP_OK=(CMD_RESP|0x0001) # command succeeded; returned parameters depend on the command issued
     RESP_ERR=(CMD_RESP|0x0002) # command failed, check stats code attached string may describe the error
     ERR_auth_failed=0x41 # auth.failed or auth.requested but no login came. in case of authentification failure due to name/pwd mismatch, server may send CMD_accessDenied instead
     ERR_conn_broken=0x42 #  connection closed or broken packet killed it */
@@ -21,41 +21,41 @@ module Rserve
 
 
     ERR_notOpen=0x47 #  attempt to perform fileRead/Write  on closed file */
-    ERR_accessDenied=0x48 #  this answer is also valid on CMD_login; otherwise it's sent if the server deosn;t allow the user to issue the specified command. (e.g. some server admins may block file I/O operations for some users) 
+    ERR_accessDenied=0x48 #  this answer is also valid on CMD_login; otherwise it's sent if the server deosn;t allow the user to issue the specified command. (e.g. some server admins may block file I/O operations for some users)
     ERR_unsupportedCmd=0x49 #  unsupported command */
     ERR_unknownCmd=0x4a #  unknown command - the difference between unsupported and unknown is that unsupported commands are known to the server but for some reasons (e.g. platform dependent) it's not supported. unknown commands are simply not recognized by the server at all. */
     ERR_data_overflow=0x4b #  incoming packet is too big. currently there is a limit as of the size of an incoming packet. */
-    ERR_object_too_big=0x4c #  the requested object is too big to be transported in that way. If received after CMD_eval then the evaluation itself was successful. optional parameter is the size of the object 
-    ERR_out_of_mem=0x4d #  out of memory. the connection is usually closed after this error was sent 
-    ERR_ctrl_closed=0x4e #  control pipe to the master process is closed or broken 
+    ERR_object_too_big=0x4c #  the requested object is too big to be transported in that way. If received after CMD_eval then the evaluation itself was successful. optional parameter is the size of the object
+    ERR_out_of_mem=0x4d #  out of memory. the connection is usually closed after this error was sent
+    ERR_ctrl_closed=0x4e #  control pipe to the master process is closed or broken
     ERR_session_busy=0x50 #  session is still busy */
     ERR_detach_failed=0x51 #  unable to detach session (cannot determine peer IP or problems creating a listening socket for resume) */
-    
-    
+
+
     CMD_login=0x001 #  "name\npwd" : - */
     CMD_voidEval=0x002 #  string : - */
     CMD_eval=0x003 #  string : encoded SEXP */
     CMD_shutdown=0x004 #  [admin-pwd] : - */
-    
+
     #/* file I/O routines. server may answe */
     CMD_openFile=0x010 #  fn : - */
     CMD_createFile=0x011 #  fn : - */
     CMD_closeFile=0x012 #  - : - */
     CMD_readFile=0x013 #  [int size] : data... ; if size not present,
-      #server is free to choose any value - usually
-      #it uses the size of its static buffer */
+    #server is free to choose any value - usually
+    #it uses the size of its static buffer */
     CMD_writeFile=0x014 #  data : - */
     CMD_removeFile=0x015 #  fn : - */
-    
+
     # /* object manipulation */
     CMD_setSEXP=0x020 #  string(name), REXP : - */
     CMD_assignSEXP=0x021 #  string(name), REXP : - ; same as setSEXP except that the name is parsed */
-    
+
     # /* session management (since 0.4-0) */
     CMD_detachSession=0x030 #  : session key */
     CMD_detachedVoidEval=0x031 #  string : session key; doesn't */
-    CMD_attachSession=0x032 #  session key : - */  
-    
+    CMD_attachSession=0x032 #  session key : - */
+
     # control commands (since 0.6-0) - passed on to the master process */
     # Note: currently all control commands are asychronous, i.e. RESP_OK
     # indicates that the command was enqueued in the master pipe, but there
@@ -68,21 +68,21 @@ module Rserve
     CMD_ctrlEval=0x42  #  string : - */
     CMD_ctrlSource=0x45  #  string : - */
     CMD_ctrlShutdown=0x44  #  - : - */
-    
+
     # /* 'internal' commands (since 0.1-9) */
     CMD_setBufferSize=0x081  #  [int sendBufSize]  this commad allow clients to request bigger buffer sizes if large data is to be transported from Rserve to the client. (incoming buffer is resized automatically) */
     CMD_setEncoding=0x082  #  string (one of "native","latin1","utf8") : -; since 0.5-3 */
-    
+
     # /* special commands - the payload of packages with this mask does not contain defined parameters */
-    
+
     CMD_SPECIAL_MASK=0xf0
-    
+
     CMD_serEval=0xf5 #  serialized eval - the packets are raw serialized data without data header */
     CMD_serAssign=0xf6 #  serialized assign - serialized list with [[1]]=name, [[2]]=value */
     CMD_serEEval=0xf7 #  serialized expression eval - like serEval with one additional evaluation round */
-    
-    #  data types for the transport protocol (QAP1)do NOT confuse with XT_.. values. 
-    
+
+    #  data types for the transport protocol (QAP1)do NOT confuse with XT_.. values.
+
     DT_INT=1  #  int */
     DT_CHAR=2  #  char */
     DT_DOUBLE=3  #  double */
@@ -110,8 +110,8 @@ module Rserve
       ERR_session_busy=>"session still busy",
       ERR_detach_failed=>"unable to detach seesion"
     } # error descriptions
-    
-    
+
+
     # writes bit-wise int to a byte buffer at specified position in Intel-endian form
     # Internal: byte buffer will be the result of unpack("CCCC") an integer.
     # @param v value to be written
@@ -123,7 +123,7 @@ module Rserve
       buf[o]=((v&0xff0000)>>16); o+=1
       buf[o]=((v&0xff000000)>>24);
     end
-    
+
     # writes cmd/resp/type byte + 3/7 bytes len into a byte buffer at specified offset.
     # @param ty type/cmd/resp byte
     # @param len length
@@ -145,58 +145,63 @@ module Rserve
     end
     # creates a new header according to the type and length of the parameter
     # @param ty type/cmd/resp byte
-    # @param len length 
+    # @param len length
     def new_hdr(ty, len)
       hdr=Array.new(  (len>0xfffff0)?8:4)
       set_hdr(ty,len,hdr,0);
       hdr
     end
-    # 
+    #
     # converts bit-wise stored int in Intel-endian form into ruby int
     #
     # @param buf buffer containg the representation
     # @param o offset where to start (4 bytes will be used)
     # @return the int value. no bounds checking is done so you need to
-    # make sure that the buffer is big enough 
-    
-    def get_int(buf, o) 
-      return buf.slice(o,4).pack("C*").unpack("I")[0]
-      #return ((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24));
+    # make sure that the buffer is big enough
+
+    def get_int(buf, o)
+      #return buf.slice(o,4).pack("C*").unpack("i")[0]
+      return ((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24));
     end
-    
+
     # converts bit-wise stored length from a header. "long" format is supported up to 32-bit
     # @param buf buffer
     # @param o offset of the header (length is at o+1)
     # @return length */
-    def get_len(buf, o) 
-# // "long" format; still - we support 32-bit only
+    def get_len(buf, o)
+      # // "long" format; still - we support 32-bit only
       if  ((buf[o]&64)>0)
+        #p "buf:#{buf} --- o: #{o} -- [#{buf[o+4]}]"
+        raise "Buffer without enough values" if buf[o+4].nil?
         (buf[o+1]&255)|((buf[o+2]&255)<<8)|((buf[o+3]&255)<<16)|((buf[o+4]&255)<<24)
       else
         (buf[o+1]&255)|((buf[o+2]&255)<<8)|((buf[o+3]&255)<<16)
       end
     end
-    
+
     # converts bit-wise Intel-endian format into long
     # @param buf buffer
     # @param o offset (8 bytes will be used)
     # @return long value */
-    def get_long(buf, o) 
+    def get_long(buf, o)
       low=(get_int(buf,o))&0xffffffff;
       hi=(get_int(buf,o+4))&0xffffffff;
       hi<<=32; hi|=low;
       hi
     end
     def longBitsToDouble(bits)
-       s = ((bits >> 63) == 0) ? 1 : -1;
-       e = ((bits >> 52) & 0x7ff)
-       m = (e == 0) ?
-                 (bits & 0xfffffffffffff) << 1 :
-                 (bits & 0xfffffffffffff) | 0x10000000000000;
-       s*m*2**(e-1075)
+      s = ((bits >> 63) == 0) ? 1 : -1;
+      e = ((bits >> 52) & 0x7ff)
+      m = (e == 0) ?
+      (bits & 0xfffffffffffff) << 1 :
+      (bits & 0xfffffffffffff) | 0x10000000000000;
+      s*m*2**(e-1075)
+    end
+    def doubleToRawLongBits(double)
+      [double].pack("d").unpack("Q")[0]
     end
-    def set_long(l, buf, o) 
-      set_int((l&0xffffffff),buf,o)
+    def set_long(l, buf, o)
+      set_int((l&0xffffffff), buf, o)
       set_int((l>>32),buf,o+4)
     end
   end

data/lib/rserve/protocol/rexpfactory.rb

@@ -2,403 +2,696 @@ module Rserve
   module Protocol
     #  representation of R-eXpressions in Ruby
     class REXPFactory
-        include Rserve::Protocol
-        # xpression type: NULL 
-        XT_NULL=0;
-        # xpression type: integer 
-        XT_INT=1;
-        # xpression type: double 
-        XT_DOUBLE=2;
-        # xpression type: String 
-        XT_STR=3;
-        # xpression type: language construct (currently content is same as list) 
-        XT_LANG=4;
-        # xpression type: symbol (content is symbol name: String) 
-        XT_SYM=5;
-        # xpression type: RBool     
-        XT_BOOL=6;
-        # xpression type: S4 object
-        #@since Rserve 0.5 
-        XT_S4=7;
-        # xpression type: generic vector (RList) 
-        XT_VECTOR=16;
-        # xpression type: dotted-pair list (RList) 
-        XT_LIST=17;
-        # xpression type: closure (there is no java class for that type (yet?). currently the body of the closure is stored in the content part of the REXP. Please note that this may change in the future!) 
-        XT_CLOS=18;
-        # xpression type: symbol name
-        # @since Rserve 0.5 
-        XT_SYMNAME=19;
-        # xpression type: dotted-pair list (w/o tags)
-        # @since Rserve 0.5 
-        XT_LIST_NOTAG=20;
-        # xpression type: dotted-pair list (w tags)
-        # @since Rserve 0.5 
-        XT_LIST_TAG=21;
-        # xpression type: language list (w/o tags)
-        # @since Rserve 0.5 
-        XT_LANG_NOTAG=22;
-        # xpression type: language list (w tags)
-        # @since Rserve 0.5 
-        XT_LANG_TAG=23;
-        # xpression type: expression vector 
-        XT_VECTOR_EXP=26;
-        # xpression type: string vector 
-        XT_VECTOR_STR=27;
-        # xpression type: int[] 
-        XT_ARRAY_INT=32;
-        # xpression type: double[] 
-        XT_ARRAY_DOUBLE=33;
-        # xpression type: String[] (currently not used, Vector is used instead) 
-        XT_ARRAY_STR=34;
-        # internal use only! this constant should never appear in a REXP 
-        XT_ARRAY_BOOL_UA=35;
-        # xpression type: RBool[] 
-        XT_ARRAY_BOOL=36;
-        # xpression type: raw (byte[])
-        # @since Rserve 0.4-? 
-        XT_RAW=37;
-        # xpression type: Complex[]
-        # @since Rserve 0.5 
-        XT_ARRAY_CPLX=38;
-        # xpression type: unknown; no assumptions can be made about the content 
-        XT_UNKNOWN=48;
-        # xpression type: RFactor; this XT is internally generated (ergo is does not come from Rsrv.h) to support RFactor class which is built from XT_ARRAY_INT 
-        XT_FACTOR=127; 
-        # used for transport only - has attribute 
-        XT_HAS_ATTR=128;
-        
-        attr_reader :type, :attr, :cont, :root_list
-        def get_REXP
-          @cont
-        end
-        def get_attr
-          attr.nil? ? nil : attr.cont
+      include Rserve::Protocol
+      # xpression type: NULL
+      XT_NULL=0;
+      # xpression type: integer
+      XT_INT=1;
+      # xpression type: double
+      XT_DOUBLE=2;
+      # xpression type: String
+      XT_STR=3;
+      # xpression type: language construct (currently content is same as list)
+      XT_LANG=4;
+      # xpression type: symbol (content is symbol name: String)
+      XT_SYM=5;
+      # xpression type: RBool
+      XT_BOOL=6;
+      # xpression type: S4 object
+      #@since Rserve 0.5
+      XT_S4=7;
+      # xpression type: generic vector (RList)
+      XT_VECTOR=16;
+      # xpression type: dotted-pair list (RList)
+      XT_LIST=17;
+      # xpression type: closure (there is no java class for that type (yet?). currently the body of the closure is stored in the content part of the REXP. Please note that this may change in the future!)
+      XT_CLOS=18;
+      # xpression type: symbol name
+      # @since Rserve 0.5
+      XT_SYMNAME=19;
+      # xpression type: dotted-pair list (w/o tags)
+      # @since Rserve 0.5
+      XT_LIST_NOTAG=20;
+      # xpression type: dotted-pair list (w tags)
+      # @since Rserve 0.5
+      XT_LIST_TAG=21;
+      # xpression type: language list (w/o tags)
+      # @since Rserve 0.5
+      XT_LANG_NOTAG=22;
+      # xpression type: language list (w tags)
+      # @since Rserve 0.5
+      XT_LANG_TAG=23;
+      # xpression type: expression vector
+      XT_VECTOR_EXP=26;
+      # xpression type: string vector
+      XT_VECTOR_STR=27;
+      # xpression type: int[]
+      XT_ARRAY_INT=32;
+      # xpression type: double[]
+      XT_ARRAY_DOUBLE=33;
+      # xpression type: String[] (currently not used, Vector is used instead)
+      XT_ARRAY_STR=34;
+      # internal use only! this constant should never appear in a REXP
+      XT_ARRAY_BOOL_UA=35;
+      # xpression type: RBool[]
+      XT_ARRAY_BOOL=36;
+      # xpression type: raw (byte[])
+      # @since Rserve 0.4-?
+      XT_RAW=37;
+      # xpression type: Complex[]
+      # @since Rserve 0.5
+      XT_ARRAY_CPLX=38;
+      # xpression type: unknown; no assumptions can be made about the content
+      XT_UNKNOWN=48;
+      # xpression type: RFactor; this XT is internally generated (ergo is does not come from Rsrv.h) to support RFactor class which is built from XT_ARRAY_INT
+      XT_FACTOR=127;
+      # used for transport only - has attribute
+      XT_HAS_ATTR=128;
+
+
+      attr_reader :type, :attr, :cont, :root_list
+      def get_REXP
+        @cont
+      end
+      def get_attr
+        attr.nil? ? nil : attr.cont
+      end
+      def sexp_mismatch(type)
+        STDERR.puts("Warning: #{type} SEXP size mismatch")
+      end
+      def initialize(*args)
+        if args.size==0
+
+        elsif
+          r=args[0]
+          r=Rserve::REXP::Null if r.nil?
+          a=r.attr
+          @cont=r
+          @attr=REXPFactory.new(a) if !a.nil?
+          if r.is_a? REXP::Null
+            @type=XT_NULL
+          elsif r.is_a? REXP::List
+            l=r.as_list
+            @type=l.named? ? XT_LIST_TAG : XT_LIST_NOTAG
+            if r.is_a? REXP::Language
+              @type = (@type==XT_LIST_TAG) ? XT_LANG_TAG : XT_LANG_NOTAG;
+            end
+          elsif r.is_a? REXP::GenericVector
+            @type = XT_VECTOR; # FIXME: may have to adjust names attr
+          elsif r.is_a? REXP::S4
+            @type = XT_S4
+          elsif r.is_a? REXP::Integer
+            @type = XT_ARRAY_INT
+          elsif r.is_a? REXP::Double
+            @type = XT_ARRAY_DOUBLE
+          elsif  r.is_a? REXP::String
+            @type = XT_ARRAY_STR
+          elsif r.is_a? REXP::Symbol
+            @type = XT_SYMNAME
+          elsif r.is_a? REXP::Raw
+            @type = XT_RAW
+          elsif r.is_a? REXP::Logical
+            @type = XT_ARRAY_BOOL
+          else
+            raise ArgumentError("***REXPFactory unable to interpret #{r}")
+          end
         end
-        def sexp_mismatch(type)
-          STDERR.puts("Warning: #{type} SEXP size mismatch") 
+      end
+      def parse_REXP(buf,o)
+        puts "buffer:#{buf.to_s} | o= #{o}" if $DEBUG
+
+        xl=get_len(buf,o)
+        has_at  = (buf[o]&128)!=0
+        is_long = (buf[o]&64 )!=0
+        xt = buf[o]&63
+        o+=4 if is_long
+        o+=4
+        eox=o+xl
+        @type=xt
+
+        @attr=REXPFactory.new()
+        @cont=nil
+        o = attr.parse_REXP(buf,o) if has_at
+
+        puts "REXP: #{xt_name(@type)}(#{@type})[#{xl}], attr?:#{has_at}, attr=[#{get_attr}]" if $DEBUG
+
+
+        if xt==XT_NULL
+          @cont=REXP::Null.new(get_attr)
+          return o
         end
-        def initialize(*args)
-          if args.size==0
-            
-          elsif
-            r=args[0]
-            r=Rserve::REXP::Null if r.nil?
-            a=r.attr
-            @attr=Factory.new(a) if !a.nil?
-            if r.is_a? REXP::Null
-              @type=XT_NULL
-            elsif r.is_a? REXP::List
-              l=r.as_list
-              @type=l.named? ? XT_LIST_TAG : XT_LIST_NOTAG
-              if r.is_a? REXPLanguage
-                @type = (@type==XT_LIST_TAG) ? XT_LANG_TAG : XT_LANG_NOTAG;
-              end
-            elsif r.is_a? REXP::GenericVector
-              @type = XT_VECTOR; # FIXME: may have to adjust names attr
-            elsif r.is_a? REXP::S4
-              @type = XT_S4
-            elsif r.is_a? REXP::Integer
-              @type = XT_ARRAY_INT
-            elsif r.is_a? REXP::Double
-              @type = XT_ARRAY_DOUBLE
-            elsif  r.is_a? REXP::String
-              @type = XT_ARRAY_STRING
-            elsif r.is_a? REXP::Symbol
-              @type = XT_SYMNAME
-            elsif r.is_a? REXP::Raw
-              @type = XT_RAW
-            elsif r.is_a? REXP::Logical
-              @type = XT_ARRAY_BOOL
-            else
-              raise ArgumentError("***REXPFactory unable to interpret #{r}")
-            end  
+        if xt==XT_DOUBLE
+          lr=get_long(buf,o)
+          d=[longBitsToDouble(lr)]
+          o+=8
+          if(o!=eox)
+            sexp_mismatch("double")
+            o=eox
           end
+          @cont=REXP::Double.new(d,get_attr)
+          return o
         end
-        def parse_REXP(buf,o)
-          xl=get_len(buf,o)
-          #p "buffer:#{buf.to_s}"
-          has_at  = (buf[o]&128)!=0
-          is_long = (buf[o]&64 )!=0
-          xt = buf[o]&63
-          o+=4 if is_long
-          o+=4
-          eox=o+xl
-          @type=xt
-          
-          @attr=REXPFactory.new()
-          @cont=nil
-          
-          o=attr.parse_REXP(buf,o) if has_at
-          
-          if xt==XT_NULL
-            @cont=REXP::Null.new(get_attr)
-            return o
-          end
-          if xt==XT_DOUBLE
-            lr=get_long(buf,o)
-            d=[longBitsToDouble(lr)]
+        if xt==XT_ARRAY_DOUBLE
+          as=(eox-o).quo(8)
+          i=0
+          d=Array.new(as)
+          while(o<eox)
+            d[i]=longBitsToDouble(get_long(buf,o))
             o+=8
-            if(o!=eox)
-              sexp_mismatch("double")
-              o=eox
-            end
-            @cont=REXP::Double.new(d,get_attr)
-            return o
-          end
-          if xt==XT_ARRAY_DOUBLE
-            as=(eox-o).quo(8)
-            i=0
-            d=Array.new(as)
-            while(o<eox)
-              d[i]=longBitsToDouble(get_long(buf,o))
-              o+=8
-              i+=1
-            end
-            if(o!=eox)
-              sexp_mismatch("double")
-              o=eox
-            end
-            @cont=REXP::Double.new(d,get_attr)
-            return o
+            i+=1
           end
-          if xt==XT_BOOL
-            b=[buf[o]]
-            if (b[0]!=0 && b[0]!=1) 
-              b[0]=REXP::Logical::NA
-            end
-            @cont=REXP::Logical.new(b,get_attr)
-            o+=1
-            return o
+          if(o!=eox)
+            sexp_mismatch("double")
+            o=eox
           end
-          if xt==XT_ARRAY_BOOL_UA
-            as=(eox-o)
-            i=0
-            d=Array.new(as)
-            (eox-i).times {|i| d[i]=buf[o+i]}
+          @cont=REXP::Double.new(d,get_attr)
+          return o
+        end
+        if xt==XT_BOOL
+          b=[buf[o]]
+          b[0]=REXP::Logical::NA if (b[0]!=0 && b[0]!=1)
+          @cont=REXP::Logical.new(b,get_attr)
+          o+=1
+          if(o!=eox)
+            sexp_mismatch("Warning: bool SEXP size mismatch\n") if (eox!=o+3) # o+3 could happen if the result was aligned (1 byte data + 3 bytes padding)
             o=eox
+          end
+          return o
+        end
+        if xt==XT_ARRAY_BOOL_UA
+          as=(eox-o)
+          i=0
+          d=Array.new(as)
+          (eox-i).times {|i| d[i]=buf[o+i]}
+          o=eox
 
-            d.length.each {|j| 
-              if d[j]!=0 and d[j]!=1
-                d[j]==REXP::Logical::NA
-              end
-            }
-            @cont=REXP::Logical.new(d,get_attr)
-            return o
+          d.length.each {|j|
+            if d[j]!=0 and d[j]!=1
+              d[j]==REXP::Logical::NA
+            end
+          }
+          @cont=REXP::Logical.new(d,get_attr)
+          return o
+        end
+        if xt==XT_ARRAY_BOOL
+          as=get_int(buf, o)
+          o+=4
+          d=Array.new(as)
+          as.times {|i| d[i]=buf[o+i]}
+          d.collect! {|v|
+            if v!=0 and v!=1
+              REXP::Logical::NA
+            else
+              v
+            end
+          }
+          o=eox
+          @cont=REXP::Logical.new(d,get_attr)
+          return o
+        end
+        if xt==XT_INT
+          i=Array.new(get_int(buf,o))
+          @cont=REXP::Integer.new(i,get_attr)
+          o+=4
+          if o!=eox
+            $STDERR.puts "int SEXP size mismatch"
+            o=eox
           end
-          if xt==XT_ARRAY_BOOL
-            as=get_int(buf, o)
+          return o
+        end
+
+        if xt==XT_ARRAY_INT
+          as=(eox-o).quo(4)
+          i=0
+          d=Array.new(as)
+          while(o<eox)
+            d[i]=get_int(buf,o)
             o+=4
-            d=Array.new(as)
-            as.times {|i| d[i]=buf[o+i]}
-            d.collect! {|v| 
-              if v!=0 and v!=1
-                REXP::Logical::NA
-              else
-                v
-              end
-            }
+            i+=1
+          end
+          if o!=eox
+            $STDERR.puts "int SEXP size mismatch"
             o=eox
-            @cont=REXP::Logical.new(d,get_attr)
-            return o
           end
-          if xt==XT_INT
-            i=Array.new(get_int(buf,o))
-            @cont=REXP::Integer.new(i,get_attr)
-            o+=4
-            if o!=eox
-              $STDERR.puts "int SEXP size mismatch"
-              o=eox
+
+          # hack for factors
+          if (!get_attr.nil?)
+            ca = get_attr().as_list().at("class");
+            ls = get_attr().as_list().at("levels");
+            if (!ca.nil? and !ls.nil? and  ca.as_string=="factor")
+              # R uses 1-based index, Java (and Ruby) uses 0-based one
+              @cont = REXP::Factor.new(d, ls.as_strings(), get_attr)
+              xt = XT_FACTOR;
             end
-            return o
           end
-          
-          if xt==XT_ARRAY_INT
-            as=(eox-o).quo(4)
-            i=0
-            d=Array.new(as)
-            while(o<eox)
-              d[i]=get_int(buf,o)
-              o+=4
-              i+=1
-            end
-            if o!=eox
-              $STDERR.puts "int SEXP size mismatch"
-              o=eox
-            end
-            
-            # hack for factors
-              if (!get_attr.nil?)
-                ca = get_attr().as_list().at("class");
-                ls = get_attr().as_list().at("levels");
-                if (!ca.nil? and !ls.nil? and  ca.as_string=="factor") 
-                  # R uses 1-based index, Java (and Ruby) uses 0-based one
-                  @cont = REXP::Factor.new(d, ls.as_strings(), get_attr)
-                  xt = XT_FACTOR;
-                end
-              end
-            
-            
-            
-              if @cont.nil?
-                @cont=REXP::Integer.new(d,get_attr)
-              end
-            return o
+
+
+
+          if @cont.nil?
+            @cont=REXP::Integer.new(d,get_attr)
           end
-          
-          # RAW not implemented yet
-          
-          
-          if xt==XT_LIST_NOTAG or xt==XT_LIST_TAG or xt==XT_LANG_NOTAG or xt==XT_LANG_TAG
-            lc=REXPFactory.new
-            nf=REXPFactory.new
-            l=Rlist.new
-            while(o<eox)
-              name=nil
-              o=lc.parse_REXP(buf,o)
-              if(xt==XT_LIST_TAG or xt==XT_LANG_TAG)
-                o=nf.parse_REXP(buf,o)
-                
-                name=nf.cont.as_string if(nf.cont.symbol? or nf.cont.string?)
-              end
-              if name.nil?
-                
-                l.add(lc.cont) 
-              else
-                l.put(name,lc.cont)
-              end
+          return o
+        end
+
+        if (xt==XT_RAW)
+          as=get_int(buf,o);
+          o+=4
+          d=buf[o,as]
+          o = eox;
+          @cont = new REXP::Raw.new(d, get_attr);
+          return o;
+        end
+
+        if xt==XT_LIST_NOTAG or xt==XT_LIST_TAG or xt==XT_LANG_NOTAG or xt==XT_LANG_TAG
+          lc=REXPFactory.new
+          nf=REXPFactory.new
+          l=Rlist.new
+          while(o<eox)
+            name=nil
+            o=lc.parse_REXP(buf,o)
+            if(xt==XT_LIST_TAG or xt==XT_LANG_TAG)
+              o=nf.parse_REXP(buf,o)
+
+              name=nf.cont.as_string if(nf.cont.symbol? or nf.cont.string?)
             end
-            
-            @cont=(xt==XT_LANG_NOTAG or xt==XT_LANG_TAG) ? 
-            REXP::Language.new(l,get_attr) : REXP::List.new(l, get_attr)
-            
-            if(o!=eox)
-              $STDERR.puts "Mismatch"
-              o=eox
+            if name.nil?
+
+              l.add(lc.cont)
+            else
+              l.put(name,lc.cont)
             end
-            
-            return o
-          
           end
-          
-          
-          # XT_LIST and XT_LANG not implemented yet
-          
-          if xt==XT_VECTOR or xt==XT_VECTOR_EXP
-            v=Array.new
-            while(o<eox)
-              xx=REXPFactory.new()
-              o = xx.parse_REXP(buf,o);
-              v.push(xx.cont);
+
+          @cont=(xt==XT_LANG_NOTAG or xt==XT_LANG_TAG) ?
+          REXP::Language.new(l,get_attr) : REXP::List.new(l, get_attr)
+
+          if(o!=eox)
+            $STDERR.puts "Mismatch"
+            o=eox
+          end
+
+          return o
+
+        end
+
+
+        # old-style lists, for comaptibility with older Rserve versions - rather inefficient since we have to convert the recusively stored structures into a flat structure
+        # NOT TESTED YET
+        if (xt==XT_LIST or xt==XT_LANG)  #
+          is_root= false
+          if (root_list.nil?)
+            root_list = Rlist.new();
+            is_root= true;
+          end
+          headf = REXPFactory.new();
+          tagf = REXPFactory.new();
+          o = headf.parse_REXP(buf, o);
+          el_index = root_list.size();
+          root_list.add(headf.cont);
+          #System.out.println("HEAD="+headf.cont);
+          o = parse_REXP(buf, o); # we use ourselves recursively for the body
+          if (o < eox)
+            o = tagf.parseREXP(buf, o);
+            #//System.out.println("TAG="+tagf.cont);
+            if (!tagf.cont.nil? and (tagf.cont.string? or tagf.cont.symbol?))
+
+              root_list.set_key_at(el_index, tagf.cont.as_string);
             end
-            if (o!=eox) 
-              sexp_mismatch("int")
-              o=eox;
+          end
+          if (is_root)
+            @cont = (xt==XT_LIST)?
+            REXP::List.new(root_list, get_attr):
+            REXP::Language.new(root_list, get_attr)
+            root_list = nil;
+            #System.out.println("result="+cont);
+          end
+          return o;
+        end
+
+
+
+
+        if xt==XT_VECTOR or xt==XT_VECTOR_EXP
+          v=Array.new
+          while(o<eox)
+            xx=REXPFactory.new()
+            o = xx.parse_REXP(buf,o);
+            v.push(xx.cont);
+          end
+          if (o!=eox)
+            sexp_mismatch("int")
+            o=eox;
+          end
+          # fixup for lists since they're stored as attributes of vectors
+          if !get_attr.nil? and !get_attr.as_list['names'].nil?
+            nam=get_attr.as_list['names']
+            names=nil
+            if nam.string?
+              names=nam.as_strings
+            elsif nam.vector?
+              l=nam.to_a
+              names=Array.new(aa.length)
+              aa.length.times {|i| names[i]=aa[i].as_string}
             end
-            # fixup for lists since they're stored as attributes of vectors
-            if !get_attr.nil? and !get_attr.as_list['names'].nil?
-              nam=get_attr.as_list['names']
-              names=nil
-              if nam.string?
-                names=nam.as_strings 
-              elsif nam.vector?
-                l=nam.to_a
-                names=Array.new(aa.length)
-                aa.length.times {|i| names[i]=aa[i].as_string}
+            l=Rlist.new(v,names)
+            @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(l,get_attr) : REXP::GenericVector.new(l,get_attr)
+          else
+
+            @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(Rlist.new(v), get_attr) : REXP::GenericVector.new(Rlist.new(v), get_attr)
+          end
+          return o
+        end
+        if xt==XT_ARRAY_STR
+          c=0
+          i=o
+          while(i<eox)
+            c+=1 if buf[i]==0
+            i+=1
+          end
+          s=Array.new(c)
+          if c>0
+            c=0; i=o;
+            while(o < eox)
+              if buf[o]==0
+                begin
+                  s[c]=buf[i,o-i].pack("C*")
+                rescue
+                  s[c]=""
+                end
+                c+=1
+                i=o+1
               end
-              l=Rlist.new(v,names)
-              @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(l,get_attr) : REXP::GenericVector.new(l,get_attr)
-            else
-              
-              @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(Rlist.new(v), get_attr) : REXP::GenericVector.new(Rlist.new(v), get_attr)
+              o+=1
             end
-            return o
+
+          end
+          @cont=REXP::String.new(s, get_attr)
+          return o
+        end
+        if xt==XT_VECTOR_STR
+          v=Array.new
+          while(o<eox)
+            xx=REXPFactory.new
+            o=xx.parse_REXP(buf,o)
+            v.push(xx.cont.as_string)
+          end
+          sa=Array.new(v.size)
+          i=0
+          while(i<sa.length)
+            sa[i]=v.get(i)
+            i+=1
           end
-          if xt==XT_ARRAY_STR
-            c=0
-            i=o
-            while(i<eox) 
-              c+=1 if buf[i]==0
-              i+=1
+          @cont=REXP::String.new(sa,get_attr)
+          return o
+        end
+
+        if (xt==XT_STR||xt==XT_SYMNAME)
+          i = o;
+          while (buf[i]!=0 && i<eox)
+            i+=1
+          end
+          if (xt==XT_STR)
+            @cont = REXP::String.new(buf[o,i-o].pack("C*"), get_attr);
+          else
+            @cont = REXP::Symbol.new(buf[o,i-o].pack("C*"))
+          end
+          o = eox;
+          return o;
+        end
+
+        if (xt==XT_SYM)
+          sym = REXPFactory.new
+          o = sym.parse_REXP(buf, o); # PRINTNAME that's all we will use
+          @cont = REXP::Symbol.new(sym.get__REXP().as_string) # content of a symbol is its printname string (so far)
+          o=eox;
+          return o;
+        end
+
+        if (xt==XT_CLOS)
+          o=eox;
+          return o;
+        end
+
+        if (xt==XT_UNKNOWN)
+          @cont = REXP::Unknown.new(get_int(buf,o), get_attr)
+          o=eox;
+          return o;
+        end
+
+        if (xt==XT_S4)
+          @cont = new REXP::S4.new(get_attr)
+          o=eox
+          return o;
+        end
+        @cont=nil
+        o=eox
+        raise "Unhandled type:#{xt}"
+        return o
+      end # def
+
+
+
+      # Calculates the length of the binary representation of the REXP including all headers.
+      # This is the amount of memory necessary to store the REXP via do@link #getBinaryRepresentationend.
+      # Please note that currently only XT_[ARRAY_]INT, XT_[ARRAY_]DOUBLE and XT_[ARRAY_]STR are supported! All other types will return 4
+      # which is the size of the header.
+      # @return length of the REXP including headers (4 or 8 bytes)*/
+      def get_binary_length
+        l=0
+        rxt = type
+        if (type==XT_LIST or type==XT_LIST_TAG or type==XT_LIST_NOTAG)
+          rxt=(!cont.as_list.nil? and cont.as_list.named?) ? XT_LIST_TAG : XT_LIST_NOTAG;
+        end
+        #System.out.print("len["+xtName(type)+"/"+xtName(rxt)+"] ");
+        rxt=XT_ARRAY_STR if (type==XT_VECTOR_STR) ; # VECTOR_STR is broken right now
+
+
+        has_attr= false;
+        a = get_attr;
+        al = nil;
+        al = a.as_list if (!a.nil?)
+        has_attr=true if (!al.nil? and al.size()>0)
+        l+=attr.get_binary_length if has_attr
+
+        if (rxt==XT_NULL or rxt==XT_S4)
+        elsif (rxt==XT_INT)
+          l+=4
+        elsif (rxt==XT_DOUBLE)
+          l+=8
+        elsif (rxt==XT_RAW)
+          l+=4 + cont.as_bytes.length
+          l=l-(l&3)+4 if ((l&3)>0)
+        elsif (rxt==XT_STR or rxt==XT_SYMNAME)
+          l+=(cont.nil?)?1:(cont.as_string.length()+1);
+          l=l-(l&3)+4 if ((l&3)>0)
+        elsif (rxt==XT_ARRAY_INT)
+          l+=cont.as_integers().length*4
+        elsif (rxt==XT_ARRAY_DOUBLE)
+          l+=cont.as_doubles().length*8
+        elsif (rxt==XT_ARRAY_CPLX)
+          l+=cont.as_doubles().length*8
+        elsif (rxt==XT_ARRAY_BOOL)
+          l += cont.as_bytes().length + 4
+          l = l - (l & 3) + 4 if ((l & 3) > 0)
+        elsif ([XT_LIST_TAG, XT_LIST_NOTAG, XT_LANG_TAG, XT_LANG_NOTAG, XT_LIST, XT_VECTOR].include? rxt)
+          lst = cont.as_list
+          i=0
+          while (i<lst.size)
+            x=lst.at(i)
+            l+=(x.nil?)?4:(REXPFactory.new(x).get_binary_length)
+            if(rxt==XT_LIST_TAG)
+              pl=l
+              s=lst.key_at(i)
+              l+=4
+              l+=(s.nil?) ? 1:(s.length+1)
+              l=l-(l&3)+4 if ((l&3)>0)
             end
-            s=Array.new(c)
-            if c>0
-              c=0; i=o;
-              while(o < eox)
-                if buf[o]==0
-                  begin
-                    s[c]=buf[i,o-i].pack("C*")
-                  rescue
-                    s[c]=""
-                  end
-                  c+=1
-                  i=o+1
-                end
-                o+=1
-              end
-              
+            i+=1
+          end
+          l=l-(l&3)+4 if ((l&3)>0)
+        elsif rxt==XT_ARRAY_STR
+          sa=cont.as_strings
+          i=0
+          sa.each do |v|
+            if(!v.nil?)
+              b=v.unpack("C*")
+              l+=b.length
             end
-            @cont=REXP::String.new(s, get_attr)
-            return o
+            l+=1
           end
-          if xt==XT_VECTOR_STR
-            v=Array.new
-            while(o<eox)
-              xx=REXP::Factory.new
-              o=xx.parse_REXP(buf,o)
-              v.push(xx.cont.as_string)
+
+          l=l-(l&3)+4 if ((l&3)>0)
+        else
+          raise "NOT IMPLEMENTED"
+        end
+        l+=4 if (l>0xfffff0)
+        l+4
+      end
+      def get_binary_representation(buf,off)
+        myl=get_binary_length;
+        is_large=(myl>0xfffff0);
+        a = get_attr;
+        al = nil;
+        al = a.as_list if (!a.nil?)
+        has_attr=(!al.nil? and al.size()>0)
+        rxt=type
+        ooff=off
+        rxt==XT_ARRAY_STR if(type==XT_VECTOR_STR) #  VECTOR_STR is broken right now
+        if (type==XT_LIST || type==XT_LIST_TAG || type==XT_LIST_NOTAG)
+          rxt=(!cont.as_list.nil? and cont.as_list.named?) ? XT_LIST_TAG : XT_LIST_NOTAG
+        end
+        set_hdr(rxt|(has_attr ? XT_HAS_ATTR : 0), myl - (is_large ? 8 : 4 ),buf,off);
+        off+=(is_large ? 8 : 4);
+        if has_attr
+          puts "REXP BIN ATTR: #{attr.cont.inspect}" if $DEBUG
+          off=attr.get_binary_representation(buf, off)
+        end
+
+
+        puts "REXP BIN: #{xt_name(rxt)}(#{rxt})[#{myl}], '#{cont.inspect}' attr?:#{has_attr}" if $DEBUG
+
+
+
+        if(rxt==XT_S4 or rxt==XT_NULL)
+        elsif(rxt==XT_INT)
+          set_int(cont.as_integer, buf, off)
+        elsif(rxt==XT_DOUBLE)
+          set_long(doubleToRawLongBits(cont.as_double), buf, off)
+        elsif(rxt==XT_ARRAY_INT)
+          ia=cont.as_integers
+          io=off
+          ia.each{|v| set_int(v,buf,io); io+=4}
+        elsif(rxt==XT_ARRAY_BOOL)
+          ba=cont.as_bytes
+          io=off
+          set_int(ba.length,buf,io)
+          io+=4
+          if(ba.length>0)
+            ba.each {|v|
+              buf[io] = ( (v == REXP::Logical::NA) ? 2 : ((v == REXP::Logical::FALSE) ? 0 : 1) );
+              io+=1
+            }
+            while ((io & 3) != 0)
+              buf[io] = 3
+              io+=1
             end
-            sa=Array.new(v.size)
-            i=0
-            while(i<sa.length)
-              sa[i]=v.get(i)
-              i+=1
+          end
+
+        elsif(rxt==XT_ARRAY_DOUBLE)
+          da=cont.as_doubles
+          io=off
+          da.each do |v|
+            set_long(doubleToRawLongBits(v),buf,io)
+            io+=8
+          end
+        elsif(rxt==XT_RAW)
+          by=cont.as_bytes
+          set_int(by.length,buf,off);
+          off+=4
+          by.each_with_index {|v,i| buf[off+i]=v}
+        elsif(rxt==XT_ARRAY_STR)
+          sa=cont.as_strings
+          io=off
+          sa.each do |v|
+            if !v.nil?
+              b=v.unpack("C*")
+              b.each_with_index{|v,index| buf[io+index]=v}
+              io+=b.length
             end
-            @cont=REXP::String.new(sa,get_attr)
-            return o
+            buf[io]=0
+            io+=1
+          end
+          i=io-off
+          while ((i&3)!=0)
+            buf[io]=1;
+            io+=1
+            i+=1              # padding if necessary..
           end
-          
-     if (xt==XT_STR||xt==XT_SYMNAME) 
-			i = o;
-			while (buf[i]!=0 && i<eox) do
-        i+=1
+
+        elsif ([XT_LIST_TAG, XT_LIST_NOTAG, XT_LANG_TAG, XT_LANG_NOTAG, XT_LIST, XT_VECTOR,XT_VECTOR_EXP].include? rxt)
+          io=off
+          #puts "io:#{io}"
+          lst=cont.as_list
+          #p lst
+          if !lst.nil?
+            lst.size.times do |i|
+              x=lst.at(i)
+              #puts "#{x}"
+              x==REXP::Null if x.nil?
+              #p buf
+              io=REXPFactory.new(x).get_binary_representation(buf,io)
+              #p buf
+              #p io
+              if(rxt==XT_LIST_TAG or rxt==XT_LANG_TAG)
+                
+                io=REXPFactory.new(REXP::Symbol.new(lst.key_at(i))).get_binary_representation(buf, io)
+
+              end
+            end #times
+          end #end if
+
+        elsif (rxt==XT_SYMNAME or rxt==XT_STR)
+          get_string_binary_representation(buf,off,cont.as_string)
+        else
+          raise "Can't represent on binary #{xt_name{rxt}}"
+        end
+
+        # end def
+        puts "END BUFFER:#{buf}" if $DEBUG
+        ooff+myl
       end
-				if (xt==XT_STR)
-					@cont = REXP::String.new(buf[o,i-o].pack("C*"), get_attr);
-          
-				else
-					@cont = REXP::Symbol.new(buf[o,i-o].pack("C*"))
+      def get_string_binary_representation(buf,off,s)
+        s||=""
+        io=off
+        b=s.unpack("C*")
+        puts "STRING REPRESENTATION: #{b}" if $DEBUG
+        b.each_with_index {|v,i| buf[io+i]=v}
+        io+=b.length
+        buf[io]=0
+        io+=1
+        while ((io&3)!=0)
+          buf[io]=0; # padding if necessary..
+          io+=1
         end
-      
-			o = eox;
-			return o;
-    end
-    
-    #not implemented  XT_SYM, 
-    
-    
-    if (xt==XT_CLOS) 
-			o=eox;
-			return o;
-    end
-		
-		if (xt==XT_UNKNOWN) 
-			@cont = REXP::Unknown.new(get_int(buf,o), get_attr)
-			o=eox;
-			return o;
-    end
-		
-		if (xt==XT_S4) 
-			@cont = new REXP::S4(get_attr)
-			o=eox
-			return o;
-    end
-          
-          @cont=nil
-          o=eox
-          raise "Unhandled type:#{xt}"
-          return o
-        end # def 
+        io
+      end
+      def xt_name(xt)
+        case xt
+        when XT_NULL then  "NULL";
+        when XT_INT then  "INT";
+        when XT_STR then  "STRING";
+        when XT_DOUBLE then  "REAL";
+        when XT_BOOL then  "BOOL";
+        when XT_ARRAY_INT then  "INT*";
+        when XT_ARRAY_STR then  "STRING*";
+        when XT_ARRAY_DOUBLE then  "REAL*";
+        when XT_ARRAY_BOOL then  "BOOL*";
+        when XT_ARRAY_CPLX then  "COMPLEX*";
+        when XT_SYM then  "SYMBOL";
+        when XT_SYMNAME then  "SYMNAME";
+        when XT_LANG then  "LANG";
+        when XT_LIST then  "LIST";
+        when XT_LIST_TAG then  "LIST+T";
+        when XT_LIST_NOTAG then  "LIST/T";
+        when XT_LANG_TAG then  "LANG+T";
+        when XT_LANG_NOTAG then  "LANG/T";
+        when XT_CLOS then  "CLOS";
+        when XT_RAW then  "RAW";
+        when XT_S4 then  "S4";
+        when XT_VECTOR then  "VECTOR";
+        when XT_VECTOR_STR then  "STRING[]";
+        when XT_VECTOR_EXP then  "EXPR[]";
+        when XT_FACTOR then  "FACTOR";
+        when XT_UNKNOWN then  "UNKNOWN";
+        else
+          "<unknown #{xt}"
+        end
+      end
+
+
+
+
+
     end # Factory
   end # end Protocol
-end # end Rserve
+end # end Rserve