path: root/gnu/usr.bin/cvs/windows-NT/SCC/scc.c

/* This file was written by Jim Kingdon, and is hereby placed
   in the public domain.  */

#include <Wtypes.h>
#include <stdio.h>
#include <direct.h> /* For chdir */


/* Bits of the interface.
   For paranoia's sake, I'm not using the same names as Microsoft.
   I don't imagine copying a few names could be a credible copyright
   case, but it seems safer to stick to only what is necessary for
   the interface to work.  */
typedef long SCC_return;
#define SCC_return_success 0
#define SCC_return_unknown_project -2
/* The file is not under SCC control.  */
#define SCC_return_non_scc_file -11
/* This operation is not supported.  I believe this status can only
   be returned from SccGet, SccAdd, SccRemove, SccHistory, or
   SccQueryInfo.  I'm not really sure what happens if it is returned
   from other calls.  */
#define SCC_return_not_supported -14
#define SCC_return_non_specific_error -15
enum SCC_command
{
	SCC_command_get,
	SCC_command_checkout,
	SCC_command_checkin,
	SCC_command_uncheckout,
	SCC_command_add,
	SCC_command_remove,
	SCC_command_diff,
	SCC_command_history,
	SCC_command_rename,
	SCC_command_properties,
	SCC_command_options
};

/* Outproc codes, for second argument to outproc.  */
#define SCC_outproc_info 1
#define SCC_outproc_warning 2
#define SCC_outproc_error 3
typedef long (*SCC_outproc) (char *, long);

typedef BOOL (*SCC_popul_proc) (LPVOID callerdat, BOOL add_keep,
                                LONG status, LPCSTR file);

/* Maximum sizes of various strings.  These are arbitrary limits
   which are imposed by the SCC.  */
/* Name argument to SccInitialize.  */
#define SCC_max_name 31
/* Path argument to SccInitialize.  */
#define SCC_max_init_path 31
/* Various paths many places in the interface.  */
#include <stdlib.h>
#define SCC_max_path _MAX_PATH

/* Bits to set in the caps used by SccInitialize.  */
#define SCC_cap_GetProjPath 0x200L
#define SCC_cap_AddFromScc 0x400L
#define SCC_cap_want_outproc 0x8000L

/* Flags for SccGet.  */
#define SCC_RECURSE 2L
/* This means to get all the files in a directory.  */
#define SCC_DIR 1L


/* We get to put whatever we want here, and the caller will pass it
   to us, so we don't need any global variables.  */
struct context {
    FILE *debuglog;
    /* Value of the CVSROOT we are currently working with (that is, the
       "open project" in SCC terminology), malloc'd, or NULL if there is
       no project currently open.  */
    char *root;
    /* Local directory (working directory in CVS parlance).  */
    char *local;
    SCC_outproc outproc;
};

#include <windows.h>

/* Report a malloc error and return the SCC_return_* value which the
   caller should return to the IDE.  Probably this should be getting
   the window argument too, but for the moment we don't need it.
   Note that we only use this for errors which occur after the
   context->outproc is set up.  */
SCC_return
malloc_error (struct context *context)
{
    (*context->outproc) ("Out of memory\n", SCC_outproc_error);
    return SCC_return_non_specific_error;
}

/* Return the version of the SCC spec, major version in the high word,
   minor version in the low word.  */
LONG
SccGetVersion ()
{
    /* We implement version 1.1 of the spec.  */
    return 0x10001;
}

SCC_return
SccInitialize (void **contextp, HWND window, LPSTR caller, LPSTR name,
               LPLONG caps, LPSTR path, LPDWORD co_comment_len,
               LPDWORD comment_len)
{
    struct context *context;
    FILE *fp;
    fp = fopen ("d:\\debug.scc", "w");
    if (fp == NULL)
        /* Do what?  Return some error value?  */
        abort ();
    context = malloc (sizeof (struct context));
    if (context == NULL)
    {
        fprintf (fp, "Out of memory\n");
        fclose (fp);
        /* Do what?  Return some error?  */
        abort ();
    }
    context->debuglog = fp;
    context->root = NULL;
    *contextp = context;
    fprintf (fp, "Made it into SccInitialize!\n");
    *caps = (SCC_cap_GetProjPath
	     | SCC_cap_AddFromScc
	     | SCC_cap_want_outproc);

    /* I think maybe this should have some more CVS-like
       name, like "CVS Root", if we decide that is what
       a SCC "project" is.  */
    strncpy (path, "CVS Project:", SCC_max_init_path);
    fprintf (fp, "Caller name is %s\n", caller);
    strncpy (name, "CVS", SCC_max_name);
    /* CVS has no limit on comment length.  But I suppose
       we need to return a value which is small enough for
       a caller to allocate a buffer this big.  Not that I
       would write a caller that way, but.....  */
    *co_comment_len = 8192;
    *comment_len = 8192;
    fflush (fp);
    return SCC_return_success;
}

SCC_return
SccUninitialize (void *context_arg)
{
    struct context *context = (struct context *)context_arg;
    if (ferror (context->debuglog))
	/* FIXME: return error value...  */
    if (fclose (context->debuglog) == EOF)
        /* FIXME: return error value, I think.  */
        ;
    free (context);
    return SCC_return_success;
}

SCC_return
SccOpenProject (void *context_arg, HWND window, LPSTR user,
                 LPSTR project, LPSTR local_proj, LPSTR aux_proj,
                 LPSTR comment, SCC_outproc outproc, LONG flags)
{
    struct context *context = (struct context *)context_arg;

    /* This can happen if the IDE opens a project which is not under
       CVS control.  I'm not sure whether checking for aux_proj
       being "" is the right way to detect this case, but it seems
       it should work because I think that the source code control
       system is what has control over the contents of aux_proj.  */
    if (aux_proj[0] == '\0')
	return SCC_return_unknown_project;

    context->root = malloc (strlen (aux_proj) + 5);
    if (context->root == NULL)
	return SCC_return_non_specific_error;
    strcpy (context->root, aux_proj);
    /* Since we don't yet support creating projects, we don't
       do anything with flags.  */

    if (outproc == 0)
    {
	/* This supposedly can happen if the IDE chooses not to implement
	   the outproc feature.  */
	fprintf (context->debuglog, "Uh oh.  outproc is a null pointer\n");
	context->root = NULL;
	fflush (context->debuglog);
	return SCC_return_non_specific_error;
    }
    context->outproc = outproc;

    fprintf (context->debuglog, "SccOpenProject (aux_proj=%s)\n", aux_proj);

    context->local = malloc (strlen (local_proj) + 5);
    if (context->local == NULL)
	return malloc_error (context);
    strcpy (context->local, local_proj);

    fflush (context->debuglog);
    return SCC_return_success;
}

SCC_return
SccCloseProject (void *context_arg)
{
    struct context *context = (struct context *)context_arg;
    fprintf (context->debuglog, "SccCloseProject\n");
    fflush (context->debuglog);
    if (context->root != NULL)
	free (context->root);
    context->root = NULL;
    return SCC_return_success;
}

/* cvs get.  */
SCC_return
SccGet (void *context_arg, HWND window, LONG num_files,
        LPSTR *file_names, LONG options, void *prov_options)
{
    struct context *context = (struct context *)context_arg;
    int i;
    char *fname;

    fprintf (context->debuglog, "SccGet: %d; files:", num_files);
#if 1
    for (i = 0; i < num_files; ++i)
    {
	fprintf (context->debuglog, "%s ", file_names[i]);
    }
#endif
    fprintf (context->debuglog, "\n");
    if (options & SCC_DIR)
	fprintf (context->debuglog, "  Get all\n");
    /* Should be using this flag to set -R vs. -l.  */
    if (options & SCC_RECURSE)
	fprintf (context->debuglog, "  recurse\n");

    for (i = 0; i < num_files; ++i)
    {
	FILE *fp;

	/* As with all file names passed to us by the SCC, these
	   file names are absolute pathnames.  I think they will
	   tend to be paths within context->local, although I
	   don't know whether there are any exceptions to that.  */
	fname = file_names[i];
	fprintf (context->debuglog, "%s ", fname);
#if 0
	fp = fopen (fname, "w");
#endif
    }
    fprintf (context->debuglog, "\nExiting SccGet\n");
    fflush (context->debuglog);
    return SCC_return_success;
}

/* cvs edit.  */
SCC_return
SccCheckout (void *context_arg, HWND window, LONG num_files,
             LPSTR *file_names, LPSTR comment, LONG options,
             void *prov_options)
{
    struct context *context = (struct context *)context_arg;
    fprintf (context->debuglog, "SccCheckout num_files=%ld\n", num_files);
    fflush (context->debuglog);
    /* For the moment we say that all files are not ours.  I'm not sure
       whether this is ever necessary; that is, whether the IDE will call
       us except where we have told the IDE that a file is under source
       control.  */
    /* I'm not sure what we would do if num_files > 1 and we wanted to
       return different statuses for different files.  */
    return SCC_return_non_scc_file;
}

/* cvs ci.  */
SCC_return
SccCheckin (void *context_arg, HWND window, LONG num_files,
            LPSTR *file_names, LPSTR comment, LONG options,
            void *prov_options)
{
    return SCC_return_not_supported;
}

/* cvs unedit.  */
SCC_return
SccUncheckout (void *context_arg, HWND window, LONG num_files,
               LPSTR *file_names, LONG options, void *prov_options)
{
    return SCC_return_not_supported;
}

/* cvs add + cvs ci, more or less, I think (but see also
   the "keep checked out" flag in options).  */
SCC_return
SccAdd (void *context_arg, HWND window, LONG num_files,
        LPSTR *file_names, LPSTR comment, LONG *options,
        void *prov_options)
{
    return SCC_return_not_supported;
}

/* cvs rm -f + cvs ci, I think.  Should barf if SCC_REMOVE_KEEP
   (or maybe just put the file there, as if the user had removed
   it and then done a "copy <saved-file> <filename>".  */
SCC_return
SccRemove (void *context_arg, HWND window, LONG num_files,
           LPSTR *file_names, LPSTR comment, LONG options,
           void *prov_options)
{
    return SCC_return_not_supported;
}

/* mv, cvs add, cvs rm, and cvs ci, I think.  */
SCC_return
SccRename (void *context_arg, HWND window, LPSTR old_name,
           LPSTR new_name)
{
    return SCC_return_not_supported;
}

/* If "contents flag", then implement this ourself.  For no
   args or checksum (which we fall back to full compare) basically a
   call to No_Diff or ? in the client case.  For timestamp, just a
   Classify_File.  Now, if contents not set, then want to do a
   cvs diff, and preferably start up WinDiff or something (to be
   determined, for now perhaps could just shove in the text).  */
SCC_return
SccDiff (void *context_arg, HWND window, LPSTR file_name,
         LONG options, void *prov_options)
{
    return SCC_return_not_supported;
}

/* cvs log, I presume.  If we want to get fancier we could bring
   up a screen more analogous to the tkCVS log window, let the user
   do "cvs update -r", etc.  */
SCC_return
SccHistory (void *context_arg, HWND window, LONG num_files,
            LPSTR file_names, LONG options, void *prov_options)
{
    return SCC_return_not_supported;
}

/* cvs status, presumably.  */
SCC_return
SccProperties (void *context_arg, HWND window, LPSTR file_name)
{
    return SCC_return_not_supported;
}

/* Not sure what this should do.  The most obvious thing is some
   kind of front-end to "cvs admin" but I'm not actually sure that
   is the most useful thing.  */
SCC_return
SccRunScc (void *context_arg, HWND window, LONG num_files,
           LPSTR *file_names)
{
    return SCC_return_not_supported;
}

/* Lots of things that we could do here.  Options to get/update
   such as -r -D -k etc. just for starters.  */
SCC_return
SccGetCommandOptions (void *context_arg, HWND window,
                      enum SCC_command command,
                      void **prov_optionsp)
{
    return SCC_return_not_supported;
}

/* Not existing CVS functionality, I don't think.
   Need to be able to tell user about what files
   are out there without actually getting them.  */
SCC_return
SccPopulateList (void *context_arg, enum SCC_command command,
                 LONG num_files,
                 LPSTR *file_names, SCC_popul_proc populate,
                 void *callerdat, LONG options)
{
    return SCC_return_success;
}

/* cvs status, sort of.  */
SCC_return
SccQueryInfo (void *context_arg, LONG num_files, LPSTR *file_names,
              LPLONG status)
{
    return SCC_return_not_supported;
}

SCC_return
SccGetEvents (void *context_arg, LPSTR file_name, LPLONG status,
              LPLONG events_remaining)
{
    /* They say this is supposed to only return cached status
       information, not go to disk or anything.  OK, although I
       haven't really figured out what calls would cause us to
       cache status without returning it then.  */
    return SCC_return_success;
}

/* This is where the user gives us the CVSROOT.  */
SCC_return
SccGetProjPath (void *context_arg, HWND window, LPSTR user,
                LPSTR proj_name, LPSTR local_proj, LPSTR aux_proj,
                BOOL allow_change, BOOL *new)
{
    /* For now we just hardcode the CVSROOT.  In the future we will
       of course prompt the user for it (simple implementation would
       have them supply a string; potentially better implementation
       would have menus or something for access methods and so on,
       although it might also have a way of bypassing that in case
       CVS supports new features that the GUI code doesn't
       understand).  We probably will also at some point want a
       "project" to encompass both a CVSROOT and a directory or
       module name within that CVSROOT, but we don't try to handle
       that yet either.  We also will want to be able to use "user"
       instead of having the username encoded in the aux_proj or
       proj_name, probably.  */

    struct context *context = (struct context *)context_arg;
    fprintf (context->debuglog, "SccGetProjPath called\n");

    /* At least for now we leave the proj_name alone, and just use
       the aux_proj.  */
    strncpy (proj_name, "zwork", SCC_max_path);
    strncpy (aux_proj, ":server:harvey:/home/kingdon/zwork/cvsroot",
	     SCC_max_path);
    if (local_proj[0] == '\0' && allow_change)
	strncpy (local_proj, "d:\\sccwork", SCC_max_path);
    /* I don't think I saw anything in the spec about this,
       but let's see if it helps.  */
    if (_chdir (local_proj) < 0)
	fprintf (context->debuglog, "Error in chdir: %s", strerror (errno));

    if (*new)
	/* It is OK for us to prompt the user for creating a new
	   project.  */
	/* We will say that the user said to create a new one.  */
	*new = 1;

    fflush (context->debuglog);
    return SCC_return_success;
}

/* Pretty much similar to SccPopulateList.  */
SCC_return
SccAddFromScc (void *context_arg, HWND window, LONG *files,
               char ***file_names)
{
    struct context *context = (struct context *)context_arg;

    /* For now we have hardcoded the notion that there are two files,
       foo.c and bar.c.  */
#define NUM_FILES 2
    if (files == NULL)
    {
	char **p;

	/* This means to free the memory that is allocated for
	   file_names.  */
	for (p = *file_names; *p != NULL; ++p)
	{
	    fprintf (context->debuglog, "Freeing %s\n", *p);
	    free (*p);
	}
    }
    else
    {
	*file_names = malloc ((NUM_FILES + 1) * sizeof (char **));
	if (*file_names == NULL)
	    return malloc_error (context);
	(*file_names)[0] = malloc (80);
	if ((*file_names)[0] == NULL)
	    return malloc_error (context);
	strcpy ((*file_names)[0], "foo.c");
	(*file_names)[1] = malloc (80);
	if ((*file_names)[1] == NULL)
	    return malloc_error (context);
	strcpy ((*file_names)[1], "bar.c");
	(*file_names)[2] = NULL;
	*files = 2;

	/* Are we supposed to also Get the files?  Or is the IDE
	   next going to call SccGet on each one?  The spec doesn't
	   say explicitly.  */
    }
    fprintf (context->debuglog, "Success in SccAddFromScc\n");
    fflush (context->debuglog);
    return SCC_return_success;
}

/* This changes several aspects of how we interact with the IDE.  */
SCC_return
SccSetOption (void *context_arg, LONG option, LONG val)
{
    return SCC_return_success;
}