C expert question

Question

Here are five typedefs for the c-brains in here. How do I port them to Java?
typedef struct {
  long endbyte;
  int  endbit;
  unsigned char *buffer;
  unsigned char *ptr;
  long storage;
} oggpack_buffer;
typedef struct {
  unsigned char *header;
  long           header_len;
  unsigned char *body;
  long           body_len;
} ogg_page;
typedef struct {
  unsigned char   *body_data;    /* bytes from packet bodies */
  long    body_storage;          /* storage elements allocated */
  long    body_fill;             /* elements stored; fill mark */
  long    body_returned;         /* elements of fill returned */
  int     *lacing_vals;    /* The values that will go to the segment table */
  ogg_int64_t *granule_vals;      /* granulepos values for headers. Not compact
                             this way, but it is simple coupled to the
                             lacing fifo */
  long    lacing_storage;
  long    lacing_fill;
  long    lacing_packet;
  long    lacing_returned;
  unsigned char    header[282];      /* working space for header encode */
  int              header_fill;
  int     e_o_s;          /* set when we have buffered the last packet in the
                             logical bitstream */
  int     b_o_s;          /* set after we've written the initial page
                             of a logical bitstream */
  long     serialno;
  int      pageno;
  ogg_int64_t  packetno;      /* sequence number for decode; the framing
                             knows where there's a hole in the data,
                             but we need coupling so that the codec
                             (which is in a seperate abstraction
                             layer) also knows about the gap */
  ogg_int64_t   granulepos;
} ogg_stream_state;
typedef struct {
  unsigned char *packet;
  long  bytes;
  long  b_o_s;
  long  e_o_s;
  ogg_int64_t  granulepos;
  ogg_int64_t  packetno;
} ogg_packet;
typedef struct {
  unsigned char *data;
  int storage;
  int fill;
  int returned;
  int unsynced;
  int headerbytes;
  int bodybytes;
} ogg_sync_state;My technique will be to translate all five of them to classes.
class oggpack_buffer {}
class ogg_page {}
class ogg_stream_state {}
class ogg_packet {}
class ogg_sync_state {}I'll change the names so they comply with the coding conventions for Java.
class OggPackBuffer {}
class OggPage {}
class OggStreamState {}
class OggPacket {}
class OggSyncState {}The first typdef is called oggpack_buffer. The first field is a long. I search for "Java data types" and it gives me this document:
http://java.sun.com/docs/books/tutorial/java/nutsandbolts/datatypes.html
This line I don't understand:
long      Long integer      64-bit two's complement
What does '64-bit two's complement' mean?
Then I search for C data types and it gives me this:
http://www.phim.unibe.ch/comp_doc/c_manual/C/CONCEPT/data_types.html
'long' is not even listed in the second document. Only 'int long'. Elsewhere I learn that the size of a 'long' in C depends on the CPU or system architecture.
So I'm stuck already in the first line. Please throw some light on the 'long' data type in C and the corresponding in Java.
Thank you.

Answer 1

The next 'typedef struct' - what a semantically strange construct - presents me with some new problems. Let's look at it:
typedef struct {
  unsigned char   *body_data;    /* bytes from packet bodies */
  long    body_storage;          /* storage elements allocated */
  long    body_fill;             /* elements stored; fill mark */
  long    body_returned;         /* elements of fill returned */
  int     *lacing_vals;    /* The values that will go to the segment table */
  ogg_int64_t *granule_vals;      /* granulepos values for headers. Not compact  this way, but it is simple coupled to the lacing fifo */
  long    lacing_storage;
  long    lacing_fill;
  long    lacing_packet;
  long    lacing_returned;
  unsigned char    header[282];      /* working space for header encode */
  int              header_fill;
  int     e_o_s;          /* set when we have buffered the last packet in the                             logical bitstream */
  int     b_o_s;          /* set after we've written the initial page of a logical bitstream */
  long     serialno;
  int      pageno;
  ogg_int64_t  packetno;      /* sequence number for decode; the framing
                             knows where there's a hole in the data,
                             but we need coupling so that the codec
                             (which is in a seperate abstraction
                             layer) also knows about the gap */
  ogg_int64_t   granulepos;
} ogg_stream_state;Apart from presenting us with some incomprehensible ogg-specific information there is a new data-type. Remember that in C, we can define your own primitive data-types. The one in question is called 'ogg_int64_t'. Go to the http://xiph.org/ website, download the libogg and libvorbis and run an XP search for header files with that name in them. One moment...
http://www.ideerdeterbumbumbum.dk/cprograms/search.PNG
A lot of hits!
http://www.ideerdeterbumbumbum.dk/cprograms/search.PNG
In the file os_types.h I find an answer. But theres a challenge for me. Look what I found in this file. Here's the file in its entirity.
#ifndef _OS_TYPES_H
#define _OS_TYPES_H
/* make it easy on the folks that want to compile the libs with a
   different malloc than stdlib */
#define _ogg_malloc  malloc
#define _ogg_calloc  calloc
#define _ogg_realloc realloc
#define _ogg_free    free
#if defined(_WIN32)
#  if defined(__CYGWIN__)
#    include <_G_config.h>
     typedef _G_int64_t ogg_int64_t;
     typedef _G_int32_t ogg_int32_t;
     typedef _G_uint32_t ogg_uint32_t;
     typedef _G_int16_t ogg_int16_t;
     typedef _G_uint16_t ogg_uint16_t;
#  elif defined(__MINGW32__)
     typedef short ogg_int16_t;                                                                            
     typedef unsigned short ogg_uint16_t;                                                                  
     typedef int ogg_int32_t;                                                                              
     typedef unsigned int ogg_uint32_t;                                                                    
     typedef long long ogg_int64_t;                                                                        
     typedef unsigned long long ogg_uint64_t; 
#  elif defined(__MWERKS__)
     typedef long long ogg_int64_t;
     typedef int ogg_int32_t;
     typedef unsigned int ogg_uint32_t;
     typedef short ogg_int16_t;
     typedef unsigned short ogg_uint16_t;
#  else
     /* MSVC/Borland */
     typedef __int64 ogg_int64_t;
     typedef __int32 ogg_int32_t;
     typedef unsigned __int32 ogg_uint32_t;
     typedef __int16 ogg_int16_t;
     typedef unsigned __int16 ogg_uint16_t;
#  endif
#elif defined(__MACOS__)
#  include <sys/types.h>
   typedef SInt16 ogg_int16_t;
   typedef UInt16 ogg_uint16_t;
   typedef SInt32 ogg_int32_t;
   typedef UInt32 ogg_uint32_t;
   typedef SInt64 ogg_int64_t;
#elif defined(__MACOSX__) /* MacOS X Framework build */
#  include <sys/types.h>
   typedef int16_t ogg_int16_t;
   typedef u_int16_t ogg_uint16_t;
   typedef int32_t ogg_int32_t;
   typedef u_int32_t ogg_uint32_t;
   typedef int64_t ogg_int64_t;
#elif defined(__BEOS__)
   /* Be */
#  include <inttypes.h>
   typedef int16_t ogg_int16_t;
   typedef u_int16_t ogg_uint16_t;
   typedef int32_t ogg_int32_t;
   typedef u_int32_t ogg_uint32_t;
   typedef int64_t ogg_int64_t;
#elif defined (__EMX__)
   /* OS/2 GCC */
   typedef short ogg_int16_t;
   typedef unsigned short ogg_uint16_t;
   typedef int ogg_int32_t;
   typedef unsigned int ogg_uint32_t;
   typedef long long ogg_int64_t;
#elif defined (DJGPP)
   /* DJGPP */
   typedef short ogg_int16_t;
   typedef int ogg_int32_t;
   typedef unsigned int ogg_uint32_t;
   typedef long long ogg_int64_t;
#elif defined(R5900)
   /* PS2 EE */
   typedef long ogg_int64_t;
   typedef int ogg_int32_t;
   typedef unsigned ogg_uint32_t;
   typedef short ogg_int16_t;
#elif defined(__SYMBIAN32__)
   /* Symbian GCC */
   typedef signed short ogg_int16_t;
   typedef unsigned short ogg_uint16_t;
   typedef signed int ogg_int32_t;
   typedef unsigned int ogg_uint32_t;
   typedef long long int ogg_int64_t;
#else
#  include <sys/types.h>
#  include <ogg/config_types.h>
#endif
#endif  /* _OS_TYPES_H */An if-else system based on OS-architecture. How strange for a Javaman! How does it do? Instinctively I get the urge to search for '_WIN32' among all the files. One moment...
I didn't find a definition of the string '_WIN32'. Now that's very strange, cause '_WIN32' is a strange string. Look at it! It looks crazy! I'm gonna search for it on Google...
I got 151.000 hits. That probably means that it's somehow a conventional syntax to say '_WIN32'. I've got to try to test this with jsalonen's program. I will include the headerfile show above into my helloworld-program with the sizeof([data-type]) dumps and see what happens.
#include <iostream>
#include "stdafx.h"
#include <stdio.h>
#include "os_types.h"
using namespace std;
void main()
  cout << "Hello World!" << endl;   cout << "Welcome to C++ Programming" << endl;
  printf("ogg_int64_t:\t%d\n", sizeof(ogg_int64_t));
  printf("short:\t%d\n", sizeof(short));
    printf("int:\t%d\n", sizeof(int));
    printf("long:\t%d\n", sizeof(long));
    printf("long long:\t%d\n", sizeof(long long));
}My my. It compiled. The output on my Pentium/XP architecture is:
C:\Documents and Settings\Morten Hjerl-Hansen\Dokumenter\temp\cproject\cproject\
Debug>cproject.exe
Hello World!
Welcome to C++ Programming
ogg_int64_t: 8
short: 2
int: 4
long: 4
long long: 8
Here's the executable if you want to try it out on your own Windows box. (Look for it near your Linux box.)
www.ideerdeterbumbumbum.dk/cprograms/cprojectv2.exe
ogg_int64_t is 8 bytes. So I have to decide between finding a Java datatype of size 8 bytes (64 bits) and representing ogg_int64_t. I definitely go for the first option. I don't have a clue why, it's a gut feeling. There are two: long and double. jsalonen said something about signs before. He (she?) said that long is signed.
How do I find out if the datatype ogg_int64_t is signed? That's easy:
#include <iostream>
#include "stdafx.h"
#include <stdio.h>
#include "os_types.h"
using namespace std;
void main()
  cout << "Hello World!" << endl;   cout << "Welcome to C++ Programming" << endl;
  ogg_int64_t dummy = -1;
  printf("dummy:\t%d\n", dummy);
}Output:
C:\Documents and Settings\Morten Hjerl-Hansen\Dokumenter\temp\cproject\cproject\
Debug>cproject.exe
Hello World!
Welcome to C++ Programming
dummy: -1
Program:
www.ideerdeterbumbumbum.dk/cprograms/cprojectv3.exe
Cool. It's signed just as Java's long, so they are completely the same. Wait...I'll just make one more test, just for the *** of it.
#include <iostream>
#include "stdafx.h"
#include <stdio.h>
#include "os_types.h"
using namespace std;
void main()
  cout << "Hello World!" << endl;   cout << "Welcome to C++ Programming" << endl;
  ogg_int64_t dummy = 0xFFFFFFFFFFFFFFFF;
  ogg_int64_t dummy2 = 0xFFFFFFFFFFFFFFFE;
  printf("dummy:\t%d\n", dummy);
  printf("dummy:\t%d\n", dummy2);
}Output:
C:\Documents and Settings\Morten Hjerl-Hansen\Dokumenter\temp\cproject\cproject\
Debug>cproject.exe
Hello World!
Welcome to C++ Programming
dummy: -1
dummy: -2
I never get used to that. The 'most significant bit' signifies the sign.
I look at the 'typedef struct' listed at the beginning of this message again. These two lines are weird:
  int     *lacing_vals;    /* The values that will go to the segment table */
  ogg_int64_t *granule_vals;      /* granulepos values for headers. Not compact  this way, but it is simple coupled to the lacing fifo */I haven't got a clue about how to translate them to Java. I read the documentation.
http://xiph.org/ogg/doc/libogg/ogg_stream_state.html
It reads:
lacing_vals
String of lacing values for the packet segments within the current page. Each value is a byte, indicating packet segment length.
granule_vals
Pointer to the lacing values for the packet segments within the current page.
I will definitely not use a java.lang.String to represent
int *lacing_vals;
Because I know that Java Strings are made upof unicodes and those are 16 bit each, just as the Java char primitive type. So I'll use a byte array, obviously. The 'granule_vals' field is harder to translate. I make a search in the code which makes it more and more like plausible that 'granule_vals' represents every Java programmers worst nightmare: absolute memory referencing. Aaa! Eeee�
How on earth do I represent t h a t? Wittgenstein said that the meaning of a sentence is it's use. This is exactly the key to what I must do now. Search for uses...frame.c in libogg has this line in it where 'granule_vals' is used:
os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));I'm happy. oggmalloc is clearly a memory allocation call of some sort. I wonder what it returns. I'll do a file search now for oggmalloc...
It's used in several places. Alas, poor C-programmers. misc.c in libvorbis reads:
#define _ogg_malloc(x) _VDBG_malloc(NULL,(x),__FILE__,__LINE__)Typical C! Just look at that 'x' there. That's generics. Like in Tiger, when we say
public interface List<E> {
void add(E x);
Iterator<E> iterator();
public interface Iterator<E> {
E next();
boolean hasNext();
}Ok. I'm getting used to it, but I haven't used that <E> notation in my programs yet. Anyway in misc.c there's a line defining VDBGmalloc:
extern void *_VDBG_malloc(void *ptr,long bytes,char *file,long line);The 'extern' keyword probably means that it is defined externally. There's a long explanation of the 'extern' keyword here
http://publications.gbdirect.co.uk/c_book/chapter4/linkage.html
that I don't care about. The only thing I'm interested in at this moment, keeping my focus, is how a method can have this return type:
void *
It makes absolutely no sense to a Java programmer, does it?
Anyway, the class is finished:
http://ideerdeterbumbumbum.dk/oggenc/dk/hjerl/ogg/OggStreamState.java