/*
* Copyright 1995, 1996 Perforce Software. All rights reserved.
*
* This file is part of Perforce - the FAST SCM System.
*/
class Enviro;
class HostEnv;
class FileSys;
class VarArray;
class Options;
class Client;
class StrDict;
class RegMatch;
class StrPtrLineReader;
/*
* Class and function definitions for the aliasing facility of the command line.
*
* - ClientCommand
* - CommandAlias
* - CommandPattern
* - CommandTransformation
* - ClientAliases
* - ClientUserStrBuf
* - OperatorP4Subst
*/
int clientRunCommand(
int argc,
char **argv,
Options &opts,
ClientUser *ui,
int &uidebug,
Error *e );
void clientParseOptions( Options &opts, int &argc, StrPtr *&argv, Error *e );
void clientParseOptions( Options &opts, int &argc, char **&argv, Error *e );
void clientSetVariables( Client &client, Options &opts );
int clientPrepareEnv ( Client &client, Options &opts, Enviro &enviro );
class CommandPattern;
/*
* ClientUserStrBuf: Enables aliases to capture the output of a command,
* as well as to provide the input of a command.
*/
class ClientUserStrBuf : public ClientUserMunge
{
public:
ClientUserStrBuf( Options &opts );
~ClientUserStrBuf();
virtual void OutputInfo( char level, const char *data );
virtual void OutputError( const char *errBuf );
virtual void OutputText( const char *data, int length );
virtual void OutputStat( StrDict *dict );
virtual void HandleError( Error *err );
virtual void Message( Error *err );
virtual void InputData( StrBuf *strbuf, Error *e );
void SetFormat( const StrPtr *fmt );
void SetInputData( const StrPtr *data );
const StrPtr *GetOutput();
int GetSeverity();
int CommandFailed();
private:
void Append( const char *s );
StrBuf input;
StrBuf output;
StrBuf format;
int severity;
} ;
/*
* A ClientCommand is a single command to be run. The actual command is
* constructed by processing the user's command according to the alias
* definitions. Initially, the user's command is read, and stored in
* a semi-parsed format. Then we iteratively transform that command, possibly
* multiple times, until we arrive at a command that we're ready to run,
* and then we run it.
*/
class ClientCommand
{
public:
ClientCommand();
~ClientCommand();
int RunCommand( StrDict *dict, Error *e );
void CopyArguments(
int argc,
char **argv,
Error *e );
void ParseOptions( Error *e );
void UpdateWorkingCommand(
int n_argn,
StrBuf *n_args,
Error *e );
int Matches( CommandPattern *, StrPtr *text );
void Transform(
int actual,
char **vec,
int numNamedArgs,
StrDict *namedArgs,
ClientCommand *result,
Error *e );
void GetActual( int ac, StrRef *val );
const StrPtr *GetInput();
const StrPtr *GetOutput();
void SetInput( const StrPtr *);
void SetOutput( const StrPtr *);
private:
void PrepareIO( StrDict *dict, Error *e );
void HandleOutput( StrDict *dict, Error *e );
void FormatCommand( StrBuf &b );
int FunctionMatches( StrPtr *text );
int HandleSpecialOperators(
int argc,
char **argv,
Options &opts,
Error *e );
void SplitArgs( Error *e );
int w_argc; // #args starting with the function word
int w_argn; // total #args, including client args
int w_argf; // position of the function word in args
StrPtr *w_argv; // pointer to the function word
StrRef *w_argp; // array of pointers, for option parsing
StrBuf *w_args; // the complete set of arguments
Options *w_opts; // the parsed client arguments.
char **c_args; // the args passed to clientRunCommand.
StrBuf inputVariable;
StrBuf outputVariable;
ClientUserStrBuf *ui;
} ;
/*
* A CommandPattern is the "left hand side" of an alias, and describes which
* user commands should be transformed by this alias.
*/
class CommandPattern
{
public:
CommandPattern();
~CommandPattern();
void Set( const StrPtr s );
void Compile( Error *e );
void Show( StrBuf &buf );
int Matches( ClientCommand *cmd );
int Formals();
void GetFormal( int ac, StrRef *var );
int IsAVariable( int ac );
private:
void ValidateFormals( Error *e );
StrBuf text;
StrBuf wordsBuf;
char **vec;
int maxVec;
int actual;
StrRef w0;
StrBuf *formals;
int *formalTypes;
enum FormalTypes { LITERAL = 1, VARIABLE = 2 } ;
} ;
/*
* A CommandTransformation is the "right hand side" of an alias, and
* describes how to modify the command and its arguments.
*/
class CommandTransformation
{
public:
CommandTransformation();
~CommandTransformation();
void Set( const StrPtr *s );
void Compile( Error *e );
void Show( StrBuf &buf );
void Transform(
ClientCommand *cmd,
int transformNo,
int numTransforms,
int numNamedArgs,
StrDict *namedArgs,
VarArray *resultCommands,
Error *e );
const StrPtr *GetInput();
const StrPtr *GetOutput();
private:
void CompileRedirection( Error *e );
void CompileSpecialOperators( Error *e );
StrBuf text;
StrBuf wordsBuf;
char **vec;
int maxVec;
int actual;
Options *opts;
int argc;
char **argv;
int fulcrum;
StrBuf inputVariable;
StrBuf outputVariable;
} ;
/*
* A CommandAlias combines a CommandPattern and 1+ CommandTransformation(s)
*/
class CommandAlias
{
public:
CommandAlias();
~CommandAlias();
void Consume( StrPtr *line );
int Complete();
void Compile( Error *e );
void Show( StrBuf &buf );
int AlreadyUsed();
int Matches( ClientCommand *cmd );
void Transform(
ClientCommand *cmd,
VarArray *resultCommands,
Error *e );
private:
void AddTransform( const StrPtr *xf, Error *e );
void CompileTransforms( const StrPtr *xfms, Error *e );
void BuildDictionary( ClientCommand *cmd, Error *e );
StrBuf text;
CommandPattern pattern;
VarArray *transforms;
int used;
StrDict *dict;
} ;
/*
* ClientAliases: manages the overall set of aliases, from the aliases file.
*
* Also provides a single static function that is the hook from ClientMain.
*/
class ClientAliases
{
public:
ClientAliases(
int argc,
char **argv,
Enviro *env,
HostEnv *hostEnv,
Error *e );
~ClientAliases();
static int ProcessAliases(
int argc,
char **argv,
int &result,
Error *e );
void LoadAliases( Error *e );
int HasCharsetError();
int HasAliases();
int HasAliasesDisabled();
void ShowAliases();
void ExpandAliases(
int argc,
char **argv,
Error *e );
int WasExpanded();
int RunCommands( Error *e );
private:
void ReadAliasesFile( Error *e );
int IsComment( StrPtr *line );
void UpdateCommands( int c, VarArray *resultCommands );
int CheckDryRun( int argc, char **argv, Error *e );
int WasAliasesCommand(
int &result,
Error *e );
int hasAliases;
int wasExpanded;
Enviro *env;
HostEnv *hostEnv;
StrBuf aliasesFilePath;
FileSys *aliasesFile;
VarArray *aliases;
VarArray *commands;
StrBufDict *ioDict;
int hasCharsetError;
int hasAliasesDisabled;
int parsedArgc;
char **parsedArgv;
} ;
/*
* AliasSubstitution: utilities for handling variable substitutions.
*/
class AliasSubstitution
{
public:
AliasSubstitution( Client *c, StrDict *d );
~AliasSubstitution();
int Substitute( StrBuf *b );
private:
void GetValue( StrPtr &var, StrBuf *val );
Client *client;
StrDict *dict;
} ;
/*
* OperatorP4Subst: uses our Regex engine to perform text substitutions.
*/
class OperatorP4Subst
{
public:
OperatorP4Subst();
~OperatorP4Subst();
void Substitute(
int argc,
char **argv,
Options &opts,
ClientUser *ui,
Error *e );
private:
void UpdateLine(
StrBuf *line,
StrBuf *result,
RegMatch *matcher,
const char *replace );
StrBuf rawData;
StrPtrLineReader *splr;
} ;