home *** CD-ROM | disk | FTP | other *** search
/ Enter 2005 March / ENTER.ISO / files / fwp-0.0.6-win32-installer.exe / ConsoleCCmds.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-12-06  |  20.1 KB  |  829 lines
  1. #include "ConsoleCCmds.h"
  2. #include "CVar.h"
  3. #include "CAlias.h"
  4. #include "ConsoleFrontEnd.h"
  5. #include "Tokenizer.h"
  6. #include "Gui.h"    // fⁿr echo
  7.  
  8.  
  9. /*
  10.     This ccmd registers a ccvar. After registering the cvar can be used by the console.
  11. */
  12. CCmdRegister::CCmdRegister():CCmd("register"){
  13.     usageStr="register [variable] <initial value>";
  14.     infoStr="registers a variable (so it can be used)";
  15. }
  16. CCmdRegister::~CCmdRegister(){
  17.     if(console!=NULL)
  18.         console->unregisterCCmd(this);
  19. }
  20.  
  21. bool CCmdRegister::exec(int argc, char* argv[]){
  22.     if(argc==1){
  23.         CVarString* cVar = new CVarString(newString(argv[0]), "<empty>");
  24.         cVar->flags = CON_FLAG_USER;
  25.         return console->registerCVar(cVar);
  26.  
  27.     }else if(argc==2){
  28.         CVarString* cVar = new CVarString(newString(argv[0]), argv[1]);
  29.         cVar->flags = CON_FLAG_USER;
  30.         return console->registerCVar(cVar);
  31.     }else{
  32.         console->print("usage: %s\n", usageStr);
  33.         return false;
  34.     }
  35. }
  36.  
  37. /*
  38.     The counterpart to register.
  39. */
  40. CCmdUnregister::CCmdUnregister():CCmd("unregister"){
  41.     usageStr="unregister [variable]";
  42.     infoStr="unregisters a variable";
  43. }
  44. CCmdUnregister::~CCmdUnregister(){
  45.     if(console!=NULL)
  46.         console->unregisterCCmd(this);
  47. }
  48.  
  49. bool CCmdUnregister::exec(int argc, char* argv[]){
  50.     if(argc==1){
  51.         CVar* cVar=console->getCVar(argv[0]);
  52.         if(cVar==NULL){
  53.             console->print("No cvar with name '%s' found.\n",argv[0]);
  54.             return false;
  55.         }else{
  56.             if( (cVar->flags & CON_FLAG_USER) != 0 ){
  57.                 return console->unregisterCVar(cVar);    // always true... or isn't it...
  58.             }else{
  59.                 console->print("'%s' is not an user-defined variable.\n", cVar->name);
  60.                 return false;
  61.             }
  62.         }
  63.     }else{
  64.         console->print("usage: %s\n", usageStr);
  65.         return false;
  66.     }
  67. }
  68.  
  69.  
  70. /*
  71.     This sets a cvar to a specific value
  72. */
  73.  
  74. CCmdSet::CCmdSet():CCmd("set"){
  75.     usageStr="set [variable] [value]";
  76.     infoStr="sets a variable to a given value";
  77. }
  78. CCmdSet::~CCmdSet(){
  79.     if(console!=NULL)
  80.         console->unregisterCCmd(this);
  81. }
  82.  
  83. bool CCmdSet::exec(int argc, char* argv[]){
  84.     char buff[CON_MAX_STRING_LENGTH];
  85.  
  86.     if(argc==2){
  87.         CVar* cVar=console->getCVar(argv[0]);
  88.         if(cVar==NULL){
  89.             console->print("No cvar with name '%s' found.\n",argv[0]);
  90.             return false;
  91.         }else{
  92.             if( (cVar->flags & CON_FLAG_READ_ONLY) == 0 ){
  93.                 if(cVar->valStrIsValid(argv[1])){
  94.                     cVar->setValStr(argv[1]);
  95.                     console->print("'%s' set to '%s' %s\n", cVar->name, cVar->getValStr(buff), cVar->changeStr);
  96.                     return true;
  97.                 }else{
  98.                     console->print("'%s' is not a valid value for '%s'\n", argv[1], cVar->name);
  99.                     return false;
  100.                 }
  101.             }else{
  102.                 console->print("'%s' is read-only.\n", cVar->name);
  103.                 return false;
  104.             }
  105.         }
  106.     }else{
  107.         console->print("usage: %s\n", usageStr);
  108.         return false;
  109.     }
  110. }
  111.  
  112.  
  113. /*
  114.     This shows the value of a cvar in the console window
  115. */
  116. CCmdVal::CCmdVal():CCmd("val"){
  117.     usageStr="val [variable]";
  118.     infoStr="displays the current value of a variable";
  119. }
  120. CCmdVal::~CCmdVal(){
  121.     if(console!=NULL)
  122.         console->unregisterCCmd(this);
  123. }
  124. bool CCmdVal::exec(int argc, char* argv[]){
  125.     char val[CON_MAX_STRING_LENGTH];
  126.     char varVal[CON_MAX_STRING_LENGTH];
  127.  
  128.     if(argc==1){
  129.         CVar* cVar=console->getCVar(argv[0]);
  130.         if(cVar!=NULL){
  131.             if( true /*console->hasAccessToCVar(cVar, CON_FLAG_READ)*/){
  132.                 cVar->getValStr(val);
  133.                 cVar->getVarValStr(varVal);
  134.                 if(streq(val, varVal))
  135.                     console->print("value of '%s': %s\n", cVar->name, val);
  136.                 else
  137.                     console->print("value of '%s': %s (internal value: %s)\n", cVar->name, val, varVal);
  138.                 return true;
  139.             }else{
  140.                 console->print("'%s': read access denied\n", cVar->name);
  141.                 return false;
  142.             }
  143.         }else{
  144.             console->print("No cvar with name '%s' found.\n",argv[0]);
  145.             return false;
  146.         }
  147.     }else{
  148.         console->print("usage: %s\n", usageStr);
  149.         return false;
  150.     }
  151. }
  152.  
  153.  
  154. /*
  155.     This shows a short help-message.
  156. */
  157. CCmdHelp::CCmdHelp():CCmd("help"){
  158.     usageStr="help";
  159.     infoStr="displays a short help message on how to use the console";
  160. }
  161. CCmdHelp::~CCmdHelp(){
  162.     if(console!=NULL)
  163.         console->unregisterCCmd(this);
  164. }
  165. bool CCmdHelp::exec(int argc, char* argv[]){
  166.     console->print("^3This is the FWP command console.\n");
  167.     console->print("^3Type 'info [command/variable]' to get information on a special command/variable.\n");
  168.     console->print("^3The commands 'ccmdlist' and 'cvarlist' list all console commands/variables.\n");
  169.     return true;
  170. }
  171.  
  172. /*
  173.     This shows some more or less usefull information about a cvar (such as value, access, val-range,...).
  174. */
  175. CCmdInfo::CCmdInfo():CCmd("info"){
  176.     usageStr="info [variable/command]";
  177.  
  178.     infoStr="displays some information about a variable or a command";
  179. }
  180. CCmdInfo::~CCmdInfo(){
  181.     if(console!=NULL)
  182.         console->unregisterCCmd(this);
  183. }
  184. bool CCmdInfo::exec(int argc, char* argv[]){
  185.     char val[CON_MAX_STRING_LENGTH];
  186.     char varVal[CON_MAX_STRING_LENGTH];
  187.     char type[CON_MAX_STRING_LENGTH];
  188.     char valRange[CON_MAX_STRING_LENGTH];
  189.     char flags[CON_MAX_STRING_LENGTH];
  190.  
  191.     if(argc==1){
  192.         CCmd* cCmd=console->getCCmd(argv[0]);
  193.         if(cCmd!=NULL){
  194.             if( true /*console->hasAccessToCCmd(cCmd, CON_FLAG_READ)*/){
  195.                 // print flags
  196.                 console->print("%s: %s\n", cCmd->name, cCmd->infoStr);
  197.                 console->print("usage: %s\n",cCmd->usageStr);
  198.                 return true;
  199.             }else{
  200.                 console->print("'%s': read access denied\n", cCmd->name);
  201.                 return false;
  202.             }
  203.         }else{
  204.             CVar* cVar=console->getCVar(argv[0]);
  205.             if(cVar!=NULL){
  206.                 if( true /*console->hasAccessToCVar(cVar, CON_FLAG_READ)*/){
  207.                     cVar->getTypeStr(type);
  208.                     cVar->getValStr(val);
  209.                     cVar->getVarValStr(varVal);
  210.                     cVar->getFlagsStr(flags);
  211.                     cVar->getValRangeStr(valRange);
  212.             
  213.  
  214.                     console->print("%s: %s\n", cVar->name, cVar->infoStr);
  215.                     console->print("type: %s | value: %s (internal value: %s) | valRange: %s\n", type, val, varVal, valRange);
  216.                     console->print("access flags: %s\n", flags);
  217.                     return true;
  218.                 }else{
  219.                     console->print("'%s': read access denied\n", cVar->name);
  220.                     return false;
  221.                 }
  222.  
  223.             }else{
  224.                 console->print("No cvar/ccmd with name '%s' found.\n",argv[0]);
  225.                 return false;
  226.             }
  227.         }
  228.     }else{
  229.         console->print("usage: %s\n", usageStr);
  230.         return false;
  231.     }
  232. }
  233.  
  234. /*
  235.     displays the 'usage'-string of a ccmd in the console window
  236. */
  237. CCmdUsage::CCmdUsage():CCmd("usage"){
  238.     usageStr="usage [command]";
  239.     infoStr="shows how to use a specific command";
  240. }
  241. CCmdUsage::~CCmdUsage(){
  242.     if(console!=NULL)
  243.         console->unregisterCCmd(this);
  244. }
  245. bool CCmdUsage::exec(int argc, char* argv[]){
  246.     if(argc==1){
  247.         CCmd* cCmd=console->getCCmd(argv[0]);
  248.         if(cCmd!=NULL){
  249.             if( true /*console->hasAccessToCCmd(cCmd, CON_FLAG_READ)*/){
  250.                 console->print("usage: %s\n",cCmd->usageStr);
  251.                 return true;
  252.             }else{
  253.                 console->print("'%s': read access denied\n", cCmd->name);
  254.                 return false;
  255.             }
  256.         }else{
  257.             console->print("no ccmd with name '%s' found.\n",argv[0]);
  258.             return false;
  259.         }
  260.     }else{
  261.         console->print("usage: %s\n", usageStr);
  262.         return false;
  263.     }
  264. }
  265.  
  266.  
  267. /*
  268.     Cycles through all valid values for a specific cvar
  269. */
  270. CCmdToggle::CCmdToggle():CCmd("toggle"){
  271.     usageStr="toggle [variable]";
  272.     infoStr="cycles through all valid values for a variable";
  273. }
  274. CCmdToggle::~CCmdToggle(){
  275.     if(console!=NULL)
  276.         console->unregisterCCmd(this);
  277. }
  278. bool CCmdToggle::exec(int argc, char* argv[]){
  279.     char buff[CON_MAX_STRING_LENGTH];
  280.  
  281.     if(argc==1){
  282.         CVar* cVar=console->getCVar(argv[0]);
  283.         if(cVar==NULL){
  284.             console->print("No cvar with name '%s' found.\n",argv[0]);
  285.             return false;
  286.         }else{
  287.             if( (cVar->flags & CON_FLAG_READ_ONLY) == 0 ){
  288.                 if(cVar->toggle()){
  289.                     console->print("'%s' set to %s %s\n", cVar->name, cVar->getValStr(buff), cVar->changeStr);
  290.                     return true;
  291.                 }else{
  292.                     console->print("couldn't toggle '%s'\n", cVar->name);
  293.                     return false;
  294.                 }
  295.             }else{
  296.                 console->print("'%s' is read-only.\n", cVar->name);
  297.                 return false;
  298.             }
  299.         }
  300.     }else{
  301.         console->print("usage: %s\n", usageStr);
  302.         return false;
  303.     }
  304. }
  305.  
  306.  
  307. /*
  308.     This 'executes' a cvar, i.e. the commands stored in it are executed by the console.
  309.     (Of course this only makes sense for string-cvars)
  310. */
  311. CCmdExecCVar::CCmdExecCVar():CCmd("execCVar"){
  312.     usageStr="execCVar [variable]";
  313.     infoStr="executes the commands stored in a variable";
  314. }
  315. CCmdExecCVar::~CCmdExecCVar(){
  316.     if(console!=NULL)
  317.         console->unregisterCCmd(this);
  318. }
  319. bool CCmdExecCVar::exec(int argc, char* argv[]){
  320.     char buff[CON_MAX_STRING_LENGTH];
  321.  
  322.     if(argc==1){
  323.         CVar* cVar=console->getCVar(argv[0]);
  324.         if(cVar==NULL){
  325.             console->print("No cvar with name '%s' found.\n",argv[0]);
  326.             return false;
  327.         }else{
  328.             if( true /*console->hasAccessToCVar(cVar, CON_FLAG_EXECUTE)*/){
  329.                 if(console->parse(cVar->getValStr(buff))){
  330.                     console->print("finished execution of '%s'\n", cVar->name);
  331.                     return true;
  332.                 }else{
  333.                     console->print("error while parsing '%s'\n", cVar->name);
  334.                     return false;
  335.                 }
  336.             }else{
  337.                 console->print("'s': execute access denied\n", cVar->name);
  338.                 return false;
  339.             }
  340.         }
  341.     }else{
  342.         console->print("usage: %s\n", usageStr);
  343.         return false;
  344.     }
  345. }
  346.  
  347. /*
  348.     Executes the commands stored in a file
  349. */
  350. CCmdExecFile::CCmdExecFile():CCmd("execFile"){
  351.     usageStr="execFile [filename]";
  352.     infoStr="executes the commands stored in a file";
  353. }
  354. CCmdExecFile::~CCmdExecFile(){
  355.     if(console!=NULL)
  356.         console->unregisterCCmd(this);
  357. }
  358. bool CCmdExecFile::exec(int argc, char* argv[]){
  359.     char buff[CON_MAX_STRING_LENGTH];
  360.     FILE *f;
  361.     int i;
  362.  
  363.     if(argc==1){
  364.         f=fopen(argv[0], "rt");
  365.         if(f==NULL){
  366.             console->print("couldn't open file '%s'.\n",argv[0]);
  367.  
  368.             return false;
  369.         }else{
  370.             while(!feof(f)){
  371.                 if(fgets(buff, CON_MAX_STRING_LENGTH, f)){        // THINKABOUTME: %nc benutzen??? (ⁿberlauf!!) && '\r' fⁿr linux && sgets() benutzen?
  372. //                    printf("--> file: %s : %i\n", buff, strlen(buff));
  373.                     for(i=0;i<(signed int)strlen(buff);i++){    // should be strlen-1 but we only read i+1, so no problem
  374.                         if(buff[i]=='/' && buff[i+1]=='/'){    // remove comments    // FIXME: comments in "" drinlassen!!
  375.                             buff[i]='\0';
  376.                             break;
  377.                         }
  378.                         if(buff[i]=='\r' || buff[i]=='\n'){
  379.                             buff[i]='\0';
  380.                             break;
  381.                         }
  382.                     }
  383.                     if(strlen(buff)>0)
  384.                         console->parse(buff);
  385. //                    console->print("<-- parsed line: %s\n", buff);
  386.                 }else{
  387. //                    printf("EOF\n");
  388. //                    fgetc(f);    // \n weglesen??
  389.                 }
  390.  
  391.             }
  392.             fclose(f);
  393.             return true;
  394.         }
  395.     }else{
  396.         console->print("usage: %s\n", usageStr);
  397.         return false;
  398.     }
  399. }
  400.  
  401.  
  402. /*
  403.     Executes the commands stored in a cvar OR, if no matching cvar is found, in a file
  404. */
  405. CCmdExec::CCmdExec():CCmd("exec"){
  406.     usageStr="exec [cvarname/filename]";
  407.     infoStr="executes the commands stored in a cvar or in a file";
  408. }
  409. CCmdExec::~CCmdExec(){
  410.     if(console!=NULL)
  411.         console->unregisterCCmd(this);
  412. }
  413. bool CCmdExec::exec(int argc, char* argv[]){
  414.     char buff[CON_MAX_STRING_LENGTH];
  415.     FILE *f;
  416.     int i;
  417.  
  418.     if(argc==1){
  419.         CVar* cVar=console->getCVar(argv[0]);
  420.         if(cVar!=NULL){
  421.             if( true /*console->hasAccessToCVar(cVar, CON_FLAG_EXECUTE)*/){
  422.                 if(console->parse(cVar->getValStr(buff))){
  423.                     console->print("finished execution of '%s'\n", cVar->name);
  424.                     return true;
  425.                 }else{
  426.                     console->print("error while parsing '%s'\n", cVar->name);
  427.                     return false;
  428.                 }
  429.             }else{
  430.                 console->print("'%s': execute access denied\n", cVar->name);
  431.                 return false;
  432.             }
  433.         }else{    // search for a file
  434.             f=fopen(argv[0], "rt");
  435.             if(f==NULL){
  436.                 console->print("no cvar or file with name '%s' found.\n",argv[0]);
  437.                 return false;
  438.             }else{
  439.                 while(!feof(f)){
  440.                     if(fgets(buff, CON_MAX_STRING_LENGTH, f)){        // THINKABOUTME: %nc benutzen??? (ⁿberlauf!!) && '\r' fⁿr linux && sgets() benutzen?
  441. //                        printf("--> file: %s : %i\n", buff, strlen(buff));
  442.                         for(i=0;i<(signed int)strlen(buff);i++){    
  443.                             if(buff[i]=='/' && buff[i+1]=='/'){    // remove comments
  444.                                 buff[i]='\0';
  445.                                 break;
  446.                             }
  447.                             if(buff[i]=='\r' || buff[i]=='\n'){
  448.                                 buff[i]='\0';
  449.                                 break;
  450.                             }
  451.                         }    //for
  452.                         if(strlen(buff)>0)
  453.                             console->parse(buff);
  454. //                        console->print("<-- parsed line: %s\n", buff);
  455.                     }else{
  456. //                        printf("EOF\n");
  457. //                        fgetc(f);    // \n weglesen??
  458.                     }    //if
  459.  
  460.                 }    //while
  461.                 fclose(f);
  462.                 return true;
  463.             }
  464.         }// if cVar!=NULL
  465.     }else{
  466.         console->print("usage: %s\n", usageStr);
  467.         return false;
  468.     }
  469. }
  470.  
  471. /*
  472.     lists all cvars currently registered to the console
  473. */
  474. CCmdCVarList::CCmdCVarList():CCmd("cvarlist"){
  475.     usageStr="cvarlist <pattern>";
  476.     infoStr="lists all console-variables";
  477. }
  478. CCmdCVarList::~CCmdCVarList(){
  479.     if(console!=NULL)
  480.         console->unregisterCCmd(this);
  481. }
  482. bool CCmdCVarList::exec(int argc, char* argv[]){
  483.     int i;
  484.     char val[CON_MAX_STRING_LENGTH];
  485.     char varVal[CON_MAX_STRING_LENGTH];
  486.     char flags[CON_MAX_STRING_LENGTH];
  487.  
  488.     if(argc==0){
  489.         for(i=0;i<CON_MAX_CVARS;i++){
  490.             if( console->cVars[i]!=NULL && true /*console->hasAccessToCVar(console->cVars[i], CON_FLAG_READ)*/){
  491.                 console->print(" %s %s: %s (int.:%s) %s\n"
  492.                     , console->cVars[i]->getFlagsStr(flags), console->cVars[i]->name, console->cVars[i]->getValStr(val),console->cVars[i]->getVarValStr(varVal), console->cVars[i]->infoStr);
  493.             }
  494.         }
  495.         return true;
  496.     }else if(argc==1){// pattern search
  497.         int count=0;
  498.         for(i=0;i<CON_MAX_CVARS;i++){
  499.             if(console->cVars[i]!=NULL && !strncmp(argv[0], console->cVars[i]->name, strlen(argv[0])) && true /*console->hasAccessToCVar(console->cVars[i], CON_FLAG_READ)*/){
  500.                 console->print(" %s %s: %s (int.:%s) %s\n"
  501.                     , console->cVars[i]->getFlagsStr(flags), console->cVars[i]->name, console->cVars[i]->getValStr(val),console->cVars[i]->getVarValStr(varVal), console->cVars[i]->infoStr);
  502.                 count++;
  503.             }
  504.         }
  505.         if(count==0){
  506.             console->print("No cvars beginning with '%s' found.\n",argv[0]);
  507.         }else{
  508.             console->print("%i cvars beginning with '%s' found.\n",count, argv[0]);
  509.         }
  510.         return true;
  511.     }else{
  512.         console->print("usage: %s\n", usageStr);
  513.         return false;
  514.     }
  515. }
  516.  
  517.  
  518. /*
  519.     Lists all ccmds that are currently registered
  520. */
  521. CCmdCCmdList::CCmdCCmdList():CCmd("ccmdlist"){
  522.     usageStr="ccmdlist <pattern>";
  523.     infoStr="lists all console-commands";
  524. }
  525. CCmdCCmdList::~CCmdCCmdList(){
  526.     if(console!=NULL)
  527.         console->unregisterCCmd(this);
  528. }
  529. bool CCmdCCmdList::exec(int argc, char* argv[]){
  530.     int i;
  531.     char flags[CON_MAX_STRING_LENGTH];
  532.  
  533.     if(argc==0){
  534.         for(i=0;i<CON_MAX_CCMDS;i++){
  535.             if( console->cCmds[i]!=NULL && true /*console->hasAccessToCCmd(console->cCmds[i], CON_FLAG_READ)*/){
  536.                 console->print(" %s %s (%s)\n"
  537.                     , console->cCmds[i]->getFlagsStr(flags), console->cCmds[i]->name, console->cCmds[i]->infoStr);
  538.             }
  539.         }
  540.         return true;
  541.     }else if(argc==1){
  542.         int count=0;
  543.         for(i=0;i<CON_MAX_CCMDS;i++){
  544.             if(console->cCmds[i]!=NULL && !strncmp(argv[0], console->cCmds[i]->name, strlen(argv[0]))){
  545.                 console->print(" %s %s (%s)\n"
  546.                     , console->cCmds[i]->getFlagsStr(flags), console->cCmds[i]->name, console->cCmds[i]->infoStr);
  547.                 count++;
  548.             }
  549.         }
  550.         if(count==0){
  551.             console->print("No ccmds beginning with '%s' found.\n",argv[0]);
  552.         }else{
  553.             console->print("%i ccmds beginning with '%s' found.\n",count, argv[0]);
  554.         }
  555.         return true;
  556.     }else{
  557.         console->print("usage: %s\n", usageStr);
  558.         return false;
  559.     }
  560. }
  561.  
  562. /*
  563.     prints a string to the consoles output window
  564. */
  565. CCmdEcho::CCmdEcho():CCmd("echo"){
  566.     usageStr="echo [string]";
  567.     infoStr="prints a string to the console window";
  568. }
  569. CCmdEcho::~CCmdEcho(){
  570.     if(console!=NULL)
  571.         console->unregisterCCmd(this);
  572. }
  573. bool CCmdEcho::exec(int argc, char* argv[]){
  574.  
  575.     if(argc==1){
  576.         int length=strlen(argv[0])+2;
  577.         char *buff=new char[length];    // create buffer to add newline to argv[0]
  578.         strcpy(buff, argv[0]);
  579.         buff[length-2]='\n';    // append newline
  580.         buff[length-1]='\0';    // and NULL
  581.         console->print(buff);
  582.         if(Gui::hud!=NULL && Gui::hud->messagebox!=NULL)
  583.             Gui::hud->messagebox->addMessage(new Message(buff));    // THINKABOUTME
  584.         delete[] buff;
  585.         return true;
  586.     }else{
  587.         console->print("usage: %s\n", usageStr);
  588.         return false;
  589.     }
  590. }
  591.  
  592.  
  593. /*
  594.     registers a string under a new alias
  595. */
  596. CCmdAlias::CCmdAlias():CCmd("alias"){
  597.     usageStr="alias [name] [string]";
  598.     infoStr="registers a string under a new alias";
  599. }
  600. CCmdAlias::~CCmdAlias(){
  601.     if(console!=NULL)
  602.         console->unregisterCCmd(this);
  603. }
  604. bool CCmdAlias::exec(int argc, char* argv[]){
  605.  
  606.     if(argc==2){
  607.         CAlias* alias=new CAlias(argv[0], argv[1]);
  608.         return console->registerAlias(alias);
  609.     }else{
  610.         console->print("usage: %s\n", usageStr);
  611.         return false;
  612.     }
  613. }
  614.  
  615.  
  616. /*
  617.     deletes an alias
  618. */
  619. CCmdDeleteAlias::CCmdDeleteAlias():CCmd("deleteAlias"){
  620.     usageStr="deleteAlias [name]";
  621.     infoStr="deletes an alias";
  622. }
  623. CCmdDeleteAlias::~CCmdDeleteAlias(){
  624.     if(console!=NULL)
  625.         console->unregisterCCmd(this);
  626. }
  627. bool CCmdDeleteAlias::exec(int argc, char* argv[]){
  628.  
  629.     if(argc==1){
  630.         CAlias* alias=console->getAlias(argv[0]);
  631.         if(alias!=NULL){
  632.             return console->deleteAlias(alias);
  633.         }else{
  634.             console->print("No alias with name '%s' found.\n", argv[0]);
  635.             return false;
  636.         }
  637.     }else{
  638.         console->print("usage: %s\n", usageStr);
  639.         return false;
  640.     }
  641. }
  642.  
  643.  
  644. /*
  645.     lists all registered aliases
  646. */
  647.  
  648.  
  649. CCmdAliasList::CCmdAliasList():CCmd("aliaslist"){
  650.     usageStr="aliasist <pattern>";
  651.     infoStr="lists all registered alias";
  652. }
  653. CCmdAliasList::~CCmdAliasList(){
  654.     if(console!=NULL)
  655.         console->unregisterCCmd(this);
  656. }
  657. bool CCmdAliasList::exec(int argc, char* argv[]){
  658.     int i;
  659.  
  660.     if(argc==0){
  661.         for(i=0;i<CON_MAX_ALIASES;i++){
  662.             if(console->aliases[i]!=NULL){
  663.                 console->print(" %s '%s'\n", console->aliases[i]->name, console->aliases[i]->string);
  664.             }
  665.         }
  666.         return true;
  667.     }else if(argc==1){
  668.  
  669.         // pattern search
  670.         console->print("Pattern search not implemented yet. Sorry.");
  671.         return false;
  672.     }else{
  673.         console->print("usage: %s\n", usageStr);
  674.         return false;
  675.     }
  676.  
  677. }
  678.  
  679.  
  680.  
  681.  
  682.  
  683.  
  684.  
  685.  
  686.  
  687.  
  688.  
  689.  
  690.  
  691.  
  692.  
  693.  
  694.  
  695.  
  696.  
  697.  
  698. CCmdConsoleToggle::CCmdConsoleToggle():CCmd("console.toggle"){
  699.  
  700.     usageStr="console.toggle";
  701.     infoStr="toggles console";
  702. }
  703.  
  704. CCmdConsoleToggle::~CCmdConsoleToggle(){
  705.     if(console!=NULL)
  706.         console->unregisterCCmd(this);
  707. }
  708.  
  709. bool CCmdConsoleToggle::exec(int argc, char* argv[]){
  710.     if(argc==0){
  711.         if(consoleFrontEnd->isActive)
  712.             consoleFrontEnd->deactivate();
  713.         else
  714.             consoleFrontEnd->activate();
  715.  
  716.         return true;
  717.     }else{
  718.         console->print("usage: %s\n", usageStr);
  719.         return false;
  720.     }
  721. }
  722.  
  723.  
  724. CCmdConsoleClear::CCmdConsoleClear():CCmd("console.clear"){
  725.  
  726.     usageStr="console.clear";
  727.     infoStr="clears all console output";
  728. }
  729.  
  730. CCmdConsoleClear::~CCmdConsoleClear(){
  731.     if(console!=NULL)
  732.         console->unregisterCCmd(this);
  733. }
  734.  
  735. bool CCmdConsoleClear::exec(int argc, char* argv[]){
  736.     if(argc==0){
  737.         console->clear();
  738.         return true;
  739.     }else{
  740.         console->print("usage: %s\n", usageStr);
  741.         return false;
  742.     }
  743. }
  744.  
  745.  
  746. CCmdConsoleStartLog::CCmdConsoleStartLog():CCmd("console.startLog"){
  747.     usageStr="console.startLog <filename>";
  748.     infoStr="logs all console output to a file (default: 'console.log')";
  749. }
  750.  
  751. CCmdConsoleStartLog::~CCmdConsoleStartLog(){
  752.     if(console!=NULL)
  753.         console->unregisterCCmd(this);
  754. }
  755.  
  756. bool CCmdConsoleStartLog::exec(int argc, char* argv[]){
  757.     if(argc==0){
  758.         console->startLog("console.log");
  759.         return true;
  760.     }else if(argc==1){
  761.         console->startLog(argv[0]);
  762.         return true;
  763.     }else{
  764.         console->print("usage: %s\n", usageStr);
  765.         return false;
  766.     }
  767. }
  768.  
  769. CCmdConsoleEndLog::CCmdConsoleEndLog():CCmd("console.endLog"){
  770.     usageStr="console.endLog";
  771.     infoStr="stops logging console output";
  772. }
  773.  
  774. CCmdConsoleEndLog::~CCmdConsoleEndLog(){
  775.     if(console!=NULL)
  776.         console->unregisterCCmd(this);
  777. }
  778.  
  779. bool CCmdConsoleEndLog::exec(int argc, char* argv[]){
  780.     if(argc==0){
  781.         console->endLog();
  782.         return true;
  783.     }else{
  784.         console->print("usage: %s\n", usageStr);
  785.         return false;
  786.     }
  787. }
  788.  
  789.  
  790. CCmdConsoleRestart::CCmdConsoleRestart():CCmd("console.restart"){
  791.     usageStr="console.restart";
  792.     infoStr="restart the console subsystem";
  793. }
  794.  
  795. CCmdConsoleRestart::~CCmdConsoleRestart(){
  796.     if(console!=NULL)
  797.         console->unregisterCCmd(this);
  798. }
  799.  
  800. bool CCmdConsoleRestart::exec(int argc, char* argv[]){
  801.     if(argc==0){
  802.         console->print("This does not work well (yet...). Sorry.\n");    // FIXME:
  803.         return true;
  804.  
  805.         //shutdownConsoleFE();
  806.         //shutdownConsole();
  807.         //return initConsoleFE();
  808.     }else{
  809.         console->print("usage: %s\n", usageStr);
  810.         return false;
  811.     }
  812. }
  813.  
  814.  
  815.  
  816.  
  817.  
  818.  
  819.  
  820.  
  821.  
  822.  
  823.  
  824.  
  825.  
  826.  
  827.  
  828.  
  829.