pubscc.h

CVS的WINDOWS版本 我们编译的平台不同 刚才的是在LINUX下的 现在是WIN下的

   LPSTR project, LPSTR local_proj,
   LPSTR aux_proj,
   LPSTR comment,

   /* This is the function which the version control system can call
      to ask the development environment to display output, or
      (SCC_outproc)0 if the development environment doesn't support
      the outproc feature.  */
   SCC_outproc outproc,

   /* One or more of the SCC_open_* settings.  */
   LONG flags);

extern SCC_return SccCloseProject (void *context_arg);

/* cvs get.  */
extern SCC_return SccGet
  (void *context_arg, HWND window,

   /* Files to get, where file_names is an array
      of num_files names.  */
   /* 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 the local directory specified by the local_proj argument
      to SccOpenProject, although I don't know whether there are any
      exceptions to that.  */
   LONG num_files,
   LPSTR *file_names,

   /* Command options.  */
   LONG options,

   void *prov_options);

/* cvs edit.  */
extern SCC_return SccCheckout
  (void *context_arg, HWND window, 

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   LPSTR comment,

   /* Command options.  I'm not sure what command options, if any, are
      defined for SccCheckout.  */
   LONG options,

   void *prov_options);

/* cvs ci.  */
extern SCC_return SccCheckin
  (void *context_arg, HWND window,

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   LPSTR comment,

   /* Command options.  */
   LONG options,

   void *prov_options);

/* cvs unedit.  */
extern SCC_return SccUncheckout
  (void *context_arg, HWND window,

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   /* Command options.  I'm not sure what command options, if any, are
      defined for SccUncheckout.  */
   LONG options,

   void *prov_options);

/* cvs add + cvs ci, more or less, I think (but see also
   the "keep checked out" flag in options).  */
extern SCC_return SccAdd
  (void *context_arg, HWND window,

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   LPSTR comment,

   /* Array of num_files command options, one for each file.  */
   LONG *options,

   void *prov_options);

/* 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>".  */
extern SCC_return SccRemove
  (void *context_arg, HWND window,

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   LPSTR comment,

   /* Command options.  */
   LONG options,

   void *prov_options);

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

/* If SCC_cmdopt_compare_files, SCC_cmdopt_consult_checksum, or
   SCC_cmdopt_consult_timestamp, then we are supposed to silently
   return a status, without providing any information directly to the
   user.  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 return text via
   outproc).  */
extern SCC_return SccDiff
  (void *context_arg, HWND window, LPSTR file_name,

   /* Command options.  */
   LONG options,

   void *prov_options);

/* 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.  */
extern SCC_return SccHistory
  (void *context_arg, HWND window,

   /* Files to operate on, where file_names is an array of num_files
      names.  */
   LONG num_files,
   LPSTR *file_names,

   /* Command options.  I'm not sure what command options,
      if any, are defined for SccHistory.  */
   LONG options,

   void *prov_options);

/* cvs status, presumably.  */
extern SCC_return SccProperties
  (void *context_arg, HWND window, LPSTR file_name);

/* 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.  */
extern SCC_return SccRunScc
  (void *context_arg, HWND window,

   LONG num_files,
   LPSTR *file_names);

/* If the user invokes version-control-system-defined behavior
   (typically by clicking an Advanced button in a dialog, e.g. the Get
   dialog), and the user clicks on that button, then the development
   environment calls SccGetCommandOptions.  The version control system
   interacts with the user and then sets *PROV_OPTIONSP to whatever it
   wants.  The development environment doesn't do anything with it,
   but does pass it to the various commands as prov_options.  If it
   calls SccGetCommandOptions again, it will pass the same value (so
   user choices from the previous "Advanced" click can serve as
   defaults).

   Note that "provider options" (prov_options) are unrelated to
   "command options" (SCC_cmdopt_*).  */

extern SCC_return SccGetCommandOptions
  (void *context_arg, HWND window,
   enum SCC_command command,
   void **prov_optionsp);

/* 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.  */
extern SCC_return SccPopulateList
  (void *context_arg, enum SCC_command command,

   LONG num_files,
   LPSTR *file_names,

   SCC_popul_proc populate,
   void *callerdat,

   /* Command options.  I'm not sure what command options,
      if any, are defined for SccPopulateList.  */
   LONG options);

/* cvs status, sort of.  */
extern SCC_return SccQueryInfo
  (void *context_arg,

   LONG num_files, LPSTR *file_names,

   /* This is an array of NUM_FILES entries.  In each one
      we store a SCC_status_* code.  */
   LPLONG status);

/* Like QueryInfo, but fast and for only a single file.  For example, the
   development environment might call this quite frequently to keep its
   screen display updated.  Supposed to only return cached status
   information, not go to disk or anything.  I assume that
   QueryInfo and probably the usual calls like Get would cause
   the version control system to cache the status in the first place.  */
extern SCC_return SccGetEvents
  (void *context_arg, LPSTR file_name,

   /* Here the version control system stores the SCC_status_* code.  */
   LPLONG status,

   LPLONG events_remaining);

/* This is where the user gives us the CVSROOT.  */
extern SCC_return SccGetProjPath
  (void *context_arg, HWND window, LPSTR user,

   /* Version control system copies in the project name
      here, up to SCC_max_path bytes.  */
   LPSTR proj_name,

   /* If allow_change, the version control system may copy
      into this field, up to SCC_max_path bytes.  */
   LPSTR local_proj,

   /* Version control system copies into this field, up to
      SCC_max_path bytes.  */
   LPSTR aux_proj,

   BOOL allow_change, BOOL *new);

/* Pretty much similar to SccPopulateList.  Not sure whether this also
   involves getting the files, or whether the development environment will
   typically call SccGet after this function.  */
extern SCC_return SccAddFromScc
  (void *context_arg, HWND window,

   /* Version control system sets *files to the number of files and
      *file_names to an array each element of which and contains the
      name of one of the files.  The names can be relative pathnames
      (e.g. "foo.c").  If files is NULL, that means something different;
      the version control system should free the memory that it allocated
      for file_names.  */
   LONG *files,
   char ***file_names);

/* This changes several aspects of how we interact with the IDE.  */
extern SCC_return SccSetOption
  (void *context_arg,
   /* One of the SCC_option_* codes.  */
   LONG option,
   /* Meaning of this will depend on the value of option.  */
   LONG val);

/* New functions with CodeWright 5.00c: SccAddRef, SccRelease,
   SccDiffToRev, SccLabel, SccLock and SccMerge.  I don't have any
   details on them.  */