Adding the BeOS port. More checkins to follow.
diff --git a/BeOS/ar-1.1/commands.c b/BeOS/ar-1.1/commands.c
new file mode 100644
index 0000000..f9304d0
--- /dev/null
+++ b/BeOS/ar-1.1/commands.c
@@ -0,0 +1,809 @@
+/*
+** commands.c - POSIX 1003.2 "ar" command
+**
+** This isn't a pure POSIX 1003.2 ar; it only manipulates Metrowerks
+** Library files, not general-purpose POSIX 1003.2 format archives.
+**
+** Dec. 14, 1997 Chris Herborth (chrish@kagi.com)
+**
+** This code is donated to the PUBLIC DOMAIN. You can use, abuse, modify,
+** redistribute, steal, or otherwise manipulate this code. No restrictions
+** at all. If you laugh at this code, you can't use it.
+**
+** This "ar" was implemented using IEEE Std 1003.2-1992 as the basis for
+** the interface, and Metrowerk's published docs detailing their library
+** format. Look inside for clues about how reality differs from MW's
+** documentation on BeOS...
+*/
+
+#include <support/Errors.h>
+#include <support/byteorder.h>
+#ifndef NO_DEBUG
+#include <assert.h>
+#define ASSERT(cond) assert(cond)
+#else
+#define ASSERT(cond) ((void)0)
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+#include <utime.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+#include "mwlib.h"
+#include "commands.h"
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+
+static const char *rcs_version_id = "$Id$";
+
+/* ----------------------------------------------------------------------
+** Local functions
+**
+** do_match() - find the index of the file, if it's in the archive; return
+** TRUE if found, else FALSE
+**/
+static int do_match( MWLib *lib, const char *file, int *idx );
+
+static int do_match( MWLib *lib, const char *file, int *idx )
+{
+ int which = 0;
+ char *name_ptr;
+
+ ASSERT( lib != NULL );
+ ASSERT( file != NULL );
+ ASSERT( idx != NULL );
+
+ /* Skip over the path, if any, so we can compare just the file name.
+ */
+ name_ptr = strrchr( file, '/' );
+ if( name_ptr == NULL ) {
+ name_ptr = (char *)file;
+ } else {
+ name_ptr++;
+ }
+
+ for( which = 0; which < lib->header.num_objects; which++ ) {
+ if( !strcmp( name_ptr, lib->names[which] ) ) {
+ *idx = which;
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/* ----------------------------------------------------------------------
+** Delete an archive member.
+**
+** This isn't really optimal; you could make a more efficient version
+** using a linked list instead of arrays for the data. This was easier
+** to write, and speed shouldn't be that big a deal here... you're not
+** likely to be dealing with thousands of files.
+*/
+static status_t delete_lib_entry( MWLib *lib, int idx, int verbose );
+
+status_t do_delete( const char *archive_name, char **files, int verbose )
+{
+ status_t retval = B_OK;
+ MWLib lib;
+ int idx = 0;
+ int which = 0;
+
+ ASSERT( archive_name != NULL );
+
+ if( files == NULL ) {
+ fprintf( stderr, "ar: %s, nothing to do\n", archive_name );
+ return B_ERROR;
+ }
+
+ retval = load_MW_lib( &lib, archive_name );
+ if( retval != B_OK ) {
+ switch( retval ) {
+ case B_FILE_NOT_FOUND:
+ fprintf( stderr, "ar: %s, file not found\n", archive_name );
+ return retval;
+ break;
+
+ default:
+ return retval;
+ break;
+ }
+ }
+
+ /* Delete the specified files.
+ */
+ for( idx = 0; files[idx] != NULL; idx++ ) {
+ if( do_match( &lib, files[idx], &which ) ) {
+ retval = delete_lib_entry( &lib, which, verbose );
+ }
+ which = 0;
+ }
+
+ /* Write the new file.
+ */
+ retval = write_MW_lib( &lib, archive_name );
+
+ return retval;
+}
+
+static status_t delete_lib_entry( MWLib *lib, int which, int verbose )
+{
+ uint32 new_num;
+ MWLibFile *new_files = NULL;
+ char **new_names = NULL;
+ char **new_data = NULL;
+ int ctr = 0;
+ int idx = 0;
+
+ ASSERT( lib != NULL );
+ ASSERT( which <= lib->header.num_objects );
+
+ new_num = lib->header.num_objects - 1;
+
+ new_files = (MWLibFile *)malloc( new_num * ( sizeof( MWLibFile ) ) );
+ new_names = (char **)malloc( new_num * ( sizeof( char * ) ) );
+ new_data = (char **)malloc( new_num * ( sizeof( char * ) ) );
+ if( new_files == NULL || new_names == NULL || new_data == NULL ) {
+ return B_NO_MEMORY;
+ }
+
+ /* Copy the contents of the old lib to the new lib, skipping the one
+ ** we want to delete.
+ */
+ for( ctr = 0; ctr < lib->header.num_objects; ctr++ ) {
+ if( ctr != which ) {
+ memcpy( &(new_files[idx]), &(lib->files[ctr]),
+ sizeof( MWLibFile ) );
+ new_names[idx] = lib->names[ctr];
+ new_data[idx] = lib->data[ctr];
+
+ idx++;
+ } else {
+ /* Free up the name and data.
+ */
+ if( verbose ) {
+ printf( "d - %s\n", lib->names[ctr] );
+ }
+
+ free( lib->names[idx] );
+ lib->names[idx] = NULL;
+ free( lib->data[idx] );
+ lib->data[idx] = NULL;
+ }
+ }
+
+ /* Free up the old lib's data.
+ */
+ free( lib->files );
+ free( lib->names );
+ free( lib->data );
+
+ lib->files = new_files;
+ lib->names = new_names;
+ lib->data = new_data;
+
+ lib->header.num_objects = new_num;
+
+ return B_OK;
+}
+
+/* ----------------------------------------------------------------------
+** Print an archive member to stdout.
+*/
+static status_t print_lib_entry( MWLib *lib, int idx, int verbose );
+
+status_t do_print( const char *archive_name, char **files, int verbose )
+{
+ status_t retval = B_OK;
+ MWLib lib;
+ int idx = 0;
+
+ ASSERT( archive_name != NULL );
+
+ retval = load_MW_lib( &lib, archive_name );
+ if( retval != B_OK ) {
+ switch( retval ) {
+ case B_FILE_NOT_FOUND:
+ fprintf( stderr, "ar: %s, file not found\n", archive_name );
+ return retval;
+ break;
+
+ default:
+ return retval;
+ break;
+ }
+ }
+
+ if( files == NULL ) {
+ /* Then we print the entire archive.
+ */
+ for( idx = 0; idx < lib.header.num_objects; idx++ ) {
+ retval = print_lib_entry( &lib, idx, verbose );
+ }
+ } else {
+ /* Then we print the specified files.
+ */
+ int which = 0;
+
+ for( idx = 0; files[idx] != NULL; idx++ ) {
+ if( do_match( &lib, files[idx], &which ) ) {
+ retval = print_lib_entry( &lib, which, verbose );
+ }
+ which = 0;
+ }
+ }
+
+ return retval;
+}
+
+static status_t print_lib_entry( MWLib *lib, int idx, int verbose )
+{
+ int recs;
+
+ ASSERT( lib != NULL );
+
+ if( verbose ) {
+ printf( "\n<%s>\n\n", lib->names[idx] );
+ }
+
+ recs = fwrite( lib->data[idx], lib->files[idx].object_size, 1, stdout );
+ fflush( stdout );
+ if( recs != 1 ) {
+ fprintf( stderr, "error printing %s, %s\n", lib->names[idx],
+ strerror( errno ) );
+ return B_OK;
+ }
+
+ return B_OK;
+}
+
+/* ----------------------------------------------------------------------
+** Add/replace/update files in an archive.
+*/
+static status_t add_lib_entry( MWLib *lib, const char *filename, int verbose );
+static status_t replace_lib_entry( MWLib *lib, const char *filename,
+ int idx, int verbose );
+static status_t load_lib_file( const char *filename,
+ char **data, MWLibFile *info );
+
+static status_t load_lib_file( const char *filename,
+ char **data, MWLibFile *info )
+{
+ status_t retval = B_OK;
+ struct stat s;
+ FILE *fp;
+ uint32 recs;
+
+ ASSERT( filename != NULL );
+ ASSERT( info != NULL );
+
+ /* Initialize the info area.
+ */
+ info->m_time = (time_t)0; /* Only this... */
+ info->off_filename = 0;
+ info->off_fullpath = 0;
+ info->off_object = 0;
+ info->object_size = 0; /* ... and this will actually be updated. */
+
+ /* stat() the file to get the info we need.
+ */
+ retval = stat( filename, &s );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't stat %s, %s\n", filename,
+ strerror( errno ) );
+ return B_FILE_NOT_FOUND;
+ }
+
+ /* Possible errors here; if you have an object that's larger
+ ** than a size_t can hold (malloc() can only allocate a size_t size,
+ ** not a full off_t)...
+ */
+ if( s.st_size > (off_t)ULONG_MAX ) {
+ fprintf( stderr, "ar: %s is too large!\n", filename );
+ return B_NO_MEMORY;
+ }
+
+ /* Allocate enough memory to hold the file data.
+ */
+ *data = (char *)malloc( (size_t)s.st_size );
+ if( *data == NULL ) {
+ fprintf( stderr, "ar: can't allocate memory for %s\n", filename );
+ return B_NO_MEMORY;
+ }
+
+ /* Read the file's data.
+ */
+ fp = fopen( filename, "r" );
+ if( fp == NULL ) {
+ fprintf( stderr, "ar: can't open %s, %s\n", filename,
+ strerror( errno ) );
+ retval = B_FILE_NOT_FOUND;
+ goto free_data_return;
+ }
+
+ recs = fread( *data, (size_t)s.st_size, 1, fp );
+ if( recs != 1 ) {
+ fprintf( stderr, "ar: can't read %s, %s\n", filename,
+ strerror( errno ) );
+ retval = B_IO_ERROR;
+ goto close_fp_return;
+ }
+
+ fclose( fp );
+
+ /* Now that all the stuff that can fail has succeeded, fill in the info
+ ** we need.
+ */
+ info->m_time = s.st_mtime;
+ info->object_size = (uint32)s.st_size;
+
+ return B_OK;
+
+ /* How we should return if an error occurred.
+ */
+close_fp_return:
+ fclose( fp );
+
+free_data_return:
+ free( *data );
+ *data = NULL;
+
+ return retval;
+}
+
+status_t do_replace( const char *archive_name, char **files, int verbose,
+ int create, int update )
+{
+ status_t retval = B_OK;
+ MWLib lib;
+ int idx = 0;
+ int which = 0;
+
+ ASSERT( archive_name != NULL );
+
+ memset( &lib, 0, sizeof( MWLib ) );
+
+ if( files == NULL ) {
+ fprintf( stderr, "ar: %s, nothing to do\n", archive_name );
+ return B_ERROR;
+ }
+
+ retval = load_MW_lib( &lib, archive_name );
+ if( retval != B_OK ) {
+ switch( retval ) {
+ case B_FILE_NOT_FOUND:
+ lib.header.magicword = 'MWOB';
+ lib.header.magicproc = 'PPC ';
+ lib.header.magicflags = 0;
+ lib.header.version = 1;
+
+ if( lib.files != NULL ) {
+ free( lib.files );
+ lib.files = NULL;
+ }
+
+ if( lib.names != NULL ) {
+ free( lib.names );
+ lib.names = NULL;
+ }
+
+ if( lib.data != NULL ) {
+ lib.data = NULL;
+ }
+
+ if( !create ) {
+ fprintf( stderr, "ar: creating %s\n", archive_name );
+ }
+
+ if( update ) {
+ fprintf( stderr, "ar: nothing to do for %s\n", archive_name );
+ return retval;
+ }
+ break;
+
+ default:
+ return retval;
+ break;
+ }
+ }
+
+ for( idx = 0; files[idx] != NULL; idx++ ) {
+ if( do_match( &lib, files[idx], &which ) ) {
+ /* Then the file exists, and we need to replace it or update it.
+ */
+ if( update ) {
+ /* Compare m_times
+ ** then replace this entry
+ */
+ struct stat s;
+
+ retval = stat( files[idx], &s );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't stat %s, %s\n", files[idx],
+ strerror( errno ) );
+ }
+
+ if( s.st_mtime >= lib.files[which].m_time ) {
+ retval = replace_lib_entry( &lib, files[idx], which,
+ verbose );
+ } else {
+ fprintf( stderr, "ar: a newer %s is already in %s\n",
+ files[idx], archive_name );
+ }
+ } else {
+ /* replace this entry
+ */
+ retval = replace_lib_entry( &lib, files[idx], which, verbose );
+ }
+ } else {
+ /* add this entry
+ */
+ retval = add_lib_entry( &lib, files[idx], verbose );
+ }
+ }
+
+ /* Write the new file.
+ */
+ retval = write_MW_lib( &lib, archive_name );
+
+ return retval;
+}
+
+static status_t add_lib_entry( MWLib *lib, const char *filename, int verbose )
+{
+ status_t retval = B_OK;
+ uint32 new_num_objects;
+ uint32 idx;
+
+ ASSERT( lib != NULL );
+ ASSERT( filename != NULL );
+
+ /* Find out how many objects we'll have after we add this one.
+ */
+ new_num_objects = lib->header.num_objects + 1;
+ idx = lib->header.num_objects;
+
+ /* Attempt to reallocate the MWLib's buffers. If one of these fails,
+ ** we could leak a little memory, but it shouldn't be a big deal in
+ ** a short-lived app like this.
+ */
+ lib->files = (MWLibFile *)realloc( lib->files,
+ sizeof(MWLibFile) * new_num_objects );
+ lib->names = (char **)realloc( lib->names,
+ sizeof(char *) * new_num_objects );
+ lib->data = (char **)realloc( lib->data,
+ sizeof(char *) * new_num_objects );
+ if( lib->files == NULL || lib->names == NULL || lib->data == NULL ) {
+ fprintf( stderr, "ar: can't allocate memory to add %s\n", filename );
+ return B_NO_MEMORY;
+ }
+
+ /* Load the file's data and info into the MWLib structure.
+ */
+ retval = load_lib_file( filename, &(lib->data[idx]), &(lib->files[idx]) );
+ if( retval != B_OK ) {
+ fprintf( stderr, "ar: error adding %s, %s\n", filename,
+ strerror( errno ) );
+
+ return retval;
+ }
+
+ /* Save a copy of the filename. This is where we leak
+ ** sizeof(MWLibFile) + 2 * sizeof(char *) bytes because we don't
+ ** shrink lib->files, lib->names, and lib->data.
+ */
+ lib->names[idx] = strdup( filename );
+ if( lib->names == NULL ) {
+ fprintf( stderr, "ar: error allocating memory for filename\n" );
+
+ return B_NO_MEMORY;
+ }
+
+ /* Now that everything's OK, we can update the MWLib header.
+ */
+ lib->header.num_objects++;
+
+ /* Give a little feedback.
+ */
+ if( verbose ) {
+ printf( "a - %s\n", filename );
+ }
+
+ return B_OK;
+}
+
+static status_t replace_lib_entry( MWLib *lib, const char *filename,
+ int idx, int verbose )
+{
+ char *buff;
+ MWLibFile info;
+ char *dup_name;
+
+ status_t retval = B_OK;
+
+ ASSERT( lib != NULL );
+ ASSERT( filename != NULL );
+ ASSERT( idx <= lib->header.num_objects );
+
+ /* Load the file's data and info into the MWLib structure.
+ **
+ ** We'll do it safely so we don't end up writing a bogus library in
+ ** the event of failure.
+ */
+ retval = load_lib_file( filename, &buff, &info );
+ if( retval != B_OK ) {
+ fprintf( stderr, "ar: error adding %s, %s\n", filename,
+ strerror( errno ) );
+
+ return retval;
+ }
+
+ /* Attempt to allocate memory for a duplicate of the file name.
+ */
+ dup_name = strdup( filename );
+ if( dup_name == NULL ) {
+ fprintf( stderr, "ar: unable to allocate memory for filename\n",
+ filename );
+
+ free( buff );
+
+ return B_NO_MEMORY;
+ }
+
+ /* All is well, so let's update the MWLib object appropriately.
+ */
+ lib->files[idx].m_time = info.m_time;
+ lib->files[idx].off_filename = 0;
+ lib->files[idx].off_fullpath = 0;
+ lib->files[idx].off_object = 0;
+ lib->files[idx].object_size = info.object_size;
+
+ lib->data[idx] = buff;
+
+ free( lib->names[idx] );
+ lib->names[idx] = dup_name;
+
+ /* Give a little feedback.
+ */
+ if( verbose ) {
+ printf( "r - %s\n", filename );
+ }
+
+ return B_OK;
+}
+
+/* ----------------------------------------------------------------------
+** Print the table for an archive.
+*/
+static status_t table_lib_entry( MWLib *lib, int idx, int verbose );
+
+status_t do_table( const char *archive_name, char **files, int verbose )
+{
+ status_t retval = B_OK;
+ MWLib lib;
+ int idx = 0;
+
+ ASSERT( archive_name != NULL );
+
+ retval = load_MW_lib( &lib, archive_name );
+ if( retval != B_OK ) {
+ switch( retval ) {
+ case B_FILE_NOT_FOUND:
+ fprintf( stderr, "ar: %s, file not found\n", archive_name );
+ return retval;
+ break;
+
+ default:
+ return retval;
+ break;
+ }
+ }
+
+ if( files == NULL ) {
+ /* Then we print the table for the entire archive.
+ */
+ for( idx = 0; idx < lib.header.num_objects; idx++ ) {
+ retval = table_lib_entry( &lib, idx, verbose );
+ }
+ } else {
+ /* Then we print the table for the specified files.
+ */
+ int which = 0;
+
+ for( idx = 0; files[idx] != NULL; idx++ ) {
+ if( do_match( &lib, files[idx], &which ) ) {
+ retval = table_lib_entry( &lib, which, verbose );
+ }
+ which = 0;
+ }
+ }
+
+ return retval;
+}
+
+static status_t table_lib_entry( MWLib *lib, int idx, int verbose )
+{
+ struct tm *t;
+ char month_buff[4];
+
+ ASSERT( lib != NULL );
+
+ if( verbose ) {
+ t = localtime( &(lib->files[idx].m_time) );
+ if( t == NULL ) {
+ fprintf( stderr, "localtime() failed, %s\n",
+ strerror( errno ) );
+ return B_OK;
+ }
+
+ if( strftime( month_buff, sizeof( month_buff ),
+ "%b", t ) == 0 ) {
+ /* TODO: error message */
+ fprintf( stderr, "strftime() failed, %s\n",
+ strerror( errno ) );
+ return B_OK;
+ }
+
+ /* I wish POSIX allowed for a nicer format; even using tabs
+ * between some entries would be better.
+ */
+ printf( "%s %u/%u %u %s %d %d:%d %d %s\n",
+ "-rw-r--r--", /* simulated mode */
+ getuid(), getgid(), /* simulated uid & gid */
+ lib->files[idx].object_size,
+ month_buff, /* abbreviated month */
+ t->tm_mon, /* day of month */
+ t->tm_hour, /* hour */
+ t->tm_min, /* minute */
+ t->tm_year, /* year */
+ lib->names[idx] );
+ } else {
+ printf( "%s\n", lib->names[idx] );
+ }
+
+ return B_OK;
+}
+
+/* ----------------------------------------------------------------------
+** Extract one or more files from the archive.
+*/
+static status_t extract_lib_entry( MWLib *lib, int idx, int verbose );
+
+status_t do_extract( const char *archive_name, char **files, int verbose )
+{
+ status_t retval = B_OK;
+ MWLib lib;
+ int idx = 0;
+
+ ASSERT( archive_name != NULL );
+
+ retval = load_MW_lib( &lib, archive_name );
+ if( retval != B_OK ) {
+ switch( retval ) {
+ case B_FILE_NOT_FOUND:
+ fprintf( stderr, "ar: %s, file not found\n", archive_name );
+ return retval;
+ break;
+
+ default:
+ return retval;
+ break;
+ }
+ }
+
+ if( files == NULL ) {
+ /* Then we extract all the files.
+ */
+ for( idx = 0; idx < lib.header.num_objects; idx++ ) {
+ retval = extract_lib_entry( &lib, idx, verbose );
+ }
+ } else {
+ /* Then we extract the specified files.
+ */
+ int which = 0;
+
+ for( idx = 0; files[idx] != NULL; idx++ ) {
+ if( do_match( &lib, files[idx], &which ) ) {
+ retval = extract_lib_entry( &lib, which, verbose );
+ }
+ which = 0;
+ }
+ }
+
+ return retval;
+}
+
+static status_t extract_lib_entry( MWLib *lib, int idx, int verbose )
+{
+ FILE *fp;
+ int recs;
+ status_t retval = B_OK;
+ struct stat s;
+ mode_t mode_bits = 0666; /* TODO: use user's umask() instead */
+
+ ASSERT( lib != NULL );
+
+ /* Delete the file if it already exists.
+ */
+ retval = access( lib->names[idx], F_OK );
+ if( retval == 0 ) {
+ retval = stat( lib->names[idx], &s );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't stat %s, %s\n", lib->names[idx],
+ strerror( errno ) );
+ } else {
+ mode_bits = s.st_mode;
+ }
+ retval = unlink( lib->names[idx] );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't unlink %s, %s\n", lib->names[idx],
+ strerror( retval ) );
+ return B_OK;
+ }
+ }
+
+ /* Write the file.
+ */
+ if( verbose ) {
+ printf( "x - %s\n", lib->names[idx] );
+ }
+
+ fp = fopen( lib->names[idx], "w" );
+ if( fp == NULL ) {
+ fprintf( stderr, "ar: can't open %s for write, %s\n", lib->names[idx],
+ strerror( errno ) );
+ return B_OK;
+ }
+
+ recs = fwrite( lib->data[idx], lib->files[idx].object_size, 1, fp );
+ if( recs != 1 ) {
+ fprintf( stderr, "error writing %s, %s\n", lib->names[idx],
+ strerror( errno ) );
+ }
+
+ retval = fclose( fp );
+
+ /* Set the newly extracted file's modification time to the time
+ ** stored in the archive.
+ */
+ retval = stat( lib->names[idx], &s );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't stat %s, %s\n", lib->names[idx],
+ strerror( errno ) );
+ } else {
+ struct utimbuf new_times;
+
+ new_times.actime = s.st_atime;
+ new_times.modtime = lib->files[idx].m_time;
+
+ retval = utime( lib->names[idx], &new_times );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: can't set modification time for %s, %s\n",
+ lib->names[idx], strerror( retval ) );
+ }
+ }
+
+ /* Set the newly extracted file's mode.
+ */
+ retval = chmod( lib->names[idx], mode_bits );
+ if( retval != 0 ) {
+ fprintf( stderr, "ar: unable to change file mode for %s, %s\n",
+ lib->names[idx], strerror( errno ) );
+ }
+
+ /* Set the newly extracted file's type.
+ */
+ setfiletype( lib->names[idx], "application/x-mw-library" );
+
+ return B_OK;
+}