WebSVN – Vertical – Diff – /branches/metal/cmdlib/cmdparse.c

 /**********
  * $Id: cmdparse.c,v 1.1.1.1 2003/11/04 23:34:56 mjames Exp $ **********
              One time Author: Kevin Ross (x6143)
                       Philips Semiconductors Limited.
                       Millbrook Industrial Estate, Southampton, SO9 7BH. England.
 There has been a lot more development, but the comments have been
 removed in order to cut down the junk
 *********************************************************************************************************/
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
-#include "cmdparse.h"
+#include <ctype.h>
-#include "cmdexec.h"
-#include "cmdlog.h"
-#include "cmdutil.h"
-#include "database.h"
 #include "expression.h"
 #include "generic.h"
-#include "vertcl_main.h"
+#include "database.h"
+#include "vertcl_main.h"
-#include <ctype.h>
+#include "cmdparse.h"
-#include <stdio.h>
+#include "cmdlog.h"
-#include <stdlib.h>
+#include "cmdutil.h"
-#include <string.h>
+#include "cmdexec.h"
 /* used for dynamic string allocation/deallocation code
  * used here for command keywords May 2 2000 */
 #include "lx_support.h"
 /*********************************************************************************************************/
-#ident                                                                                        \
-    "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/cmdlib/cmdparse.c,v 1.1.1.1 2003/11/04 23:34:56 mjames Exp $"
+#ident "@(#)$Header: c:\\cygwin\\cvsroot/Vert03/cmdlib/cmdparse.c,v 1.1.1.1 2003/11/04 23:34:56 mjames Exp $"
-/******************************************* Execute a command
+/******************************************* Execute a command  ******************************************/
- * ******************************************/
 /* define flag for global control of execution mode
  * can be Tcl_Cmd or  Tcl_GUI : default to be Tcl_Cmd for
  * backwards compatibility */
 tcl_mode_t tcl_mode = Tcl_Cmd;
 #define WORDWIDTH 100 /* max command word  ever expected */
-#define CMDWIDTH 20   /*Field width for printing CMD word */
+#define CMDWIDTH  20 /*Field width for printing CMD word */
-int Execute (int argc, char *argv[], struct command Dispatch[])
+int Execute (int argc,char * argv[], struct command Dispatch[])
-{
+   {
-        int i, j, FinalResult = UNKNOWNCMD;
+   int i,j, FinalResult = UNKNOWNCMD;
-        if (!argc)
+   if(!argc)
-                return (NARGS);
+     return(NARGS);
-        if (argv[0][0] == '?')
+   if(argv[0][0] == '?')
-        {
+     {
-                printf ("Commands available;\nHelp on:");
+     printf("Commands available;\nHelp on:");
-                for (i = 0; i < argc; i++)
+     for(i=0; i< argc;i++)
-                        printf ("%s ", argv[i]);
+       printf("%s ",argv[i]);
-                putchar ('\n');
+     putchar ('\n');
-                for (i = 0; Dispatch[i].name; i++)
+     for (i=0; Dispatch[i].name; i++)
-                {
+       {
-                        int p;
+       int p;
-                        for (j = 0; j < Dispatch[i].NumChar;
-                             j++) /* upper case significant chars */
+       for(j=0;j<Dispatch[i].NumChar;j++)     /* upper case significant chars */
-                                putchar (toupper (Dispatch[i].name[j]));
+         putchar(toupper(Dispatch[i].name[j]));
-                        for (; Dispatch[i].name[j];
-                             j++) /* and all of the rest, we just print */
+       for(;Dispatch[i].name[j];j++)          /* and all of the rest, we just print */
-                                putchar (Dispatch[i].name[j]);
+         putchar(Dispatch[i].name[j]);
-                        putchar (' ');
-                        j++;
+       putchar(' '); j++;
-                        if (Dispatch[i].extras)
+       if(Dispatch[i].extras) {
-                        {
+         p=j;
-                                p = j;
-                                for (; Dispatch[i].extras[j - p];
-                                     j++) /* and all of the extras field we just print */
+         for(;Dispatch[i].extras[j-p];j++)    /* and all of the extras field we just print */
-                                        putchar (Dispatch[i].extras[j - p]);
+         putchar(Dispatch[i].extras[j-p]);
-                        };
+         };
-                        for (; j < CMDWIDTH; j++) /* create spacing , relies on auto - wrap */
+      for(;j<CMDWIDTH;j++)                  /* create spacing , relies on auto - wrap */
-                                putchar (j & 1 ? '.' : ' ');
+         putchar(j&1 ? '.' : ' ');
-                        putchar (' ');
+       putchar(' ');
-                        puts (Dispatch[i].helpstr);
+       puts(Dispatch[i].helpstr);
-                }
+       }
-                putchar ('\n');
+     putchar('\n');
-                FinalResult = OKCMD; /* ? is a valid command at this level */
+     FinalResult = OKCMD; /* ? is a valid command at this level */
-        }
+     }
-        else
+   else
-        {
+     {
-                for (i = 0; Dispatch[i].name; i++)
+     for (i=0; Dispatch[i].name; i++)
-                        if (strncmp (argv[0], Dispatch[i].name, Dispatch[i].NumChar) == 0)
+       if (strncmp (argv[0], Dispatch[i].name, Dispatch[i].NumChar)==0)
-                        {
+         {
-                                /* Dispatch the next level command */
+          /* Dispatch the next level command */
-                                if (Dispatch[i].function)
-                                { /* call function if there */
+         if (Dispatch[i].function){ /* call function if there */
-                                        FinalResult = (*Dispatch[i].function) (
-                                            Tcl_interp, NULL, argc - 1, argv + 1);
+           FinalResult=(*Dispatch[i].function) (Tcl_interp,NULL,argc-1,argv+1);
-                                }
+           }
-                                else /* call down the menu */
+         else                      /* call down the menu */
-                                        FinalResult =
-                                            Execute (argc - 1, argv + 1, Dispatch[i].Menu);
+           FinalResult=Execute(argc-1,argv+1,Dispatch[i].Menu);
-                                break;
+         break;
-                        }
+         }
-        }
+     }
-        return (FinalResult);
+   return (FinalResult);
-}
+   }
-/******************************************** Strip off words
+/******************************************** Strip off words ********************************************/
- * ********************************************/
 /* this needs repairing . This code is unsafe.
  * Needs to keep a record of how many chars copied !!
  * and stop when in danger of a buffer overflow.
+ *
  * Did not work properly if expanded strings are longer than the
  * original strings. This now fixed.
+ *
  * Code modified to use some string allocation functions in lx_support.c
  */
 /*char wordbuff[1024];
- */
+*/
-typedef enum
+typedef enum  { SPACES,CHARS } Phase_t;
-{
-        SPACES,
+int FindWords (char * linebuff, int * pargc, char * argv[],int nArgs, char *  Args[],
-        CHARS
+       struct str ** cmd_first,struct str ** cmd_last
-} Phase_t;
+        )
+   {
-int FindWords (
+   char  *WordPtr;
-    char *linebuff,
+   char * BasePtr;
-    int *pargc,
+   int  argc = 0;
-    char *argv[],
+   int  term = ' ',escape,comment,done_word,chars_seen;
-    int nArgs,
+   char * copy_buff;
-    char *Args[],
+   Phase_t Phase ;
-    struct str **cmd_first,
-    struct str **cmd_last)
-{
+   copy_buff = malloc(strlen(linebuff)+1); /* make a safe copy */
-        char *WordPtr;
-        char *BasePtr;
+/*      for (i=0; i<Len; i++)                               */
-        int argc = 0;
+/*         Cmd->Text[i] = tolower(Cmd->Text[i]);            */     /* convert text to lower case */
-        int term = ' ', escape, comment, done_word, chars_seen;
+   WordPtr = linebuff;                                   /* set LineStart to beginning of string */
-        char *copy_buff;
+   escape = 0;
-        Phase_t Phase;
+   comment = 0;
+                               /* Now split off the words */
-        copy_buff = malloc (strlen (linebuff) + 1); /* make a safe copy */
+   BasePtr = NULL;
+   while (*WordPtr && argc < WORDSINLINE && comment<2)
-        /*      for (i=0; i<Len; i++)                               */
+     {
-        /*         Cmd->Text[i] = tolower(Cmd->Text[i]);            */ /* convert text to lower
+     BasePtr = copy_buff;
-                                                                          case */
+     Phase = SPACES;
-        WordPtr = linebuff; /* set LineStart to beginning of string */
+     term = ' ';
-        escape = 0;
+     done_word = 0;
-        comment = 0;
+     chars_seen = 0;
-        /* Now split off the words */
+     while(*WordPtr && !done_word && comment <2)
-        BasePtr = NULL;
+       {
-        while (*WordPtr && argc < WORDSINLINE && comment < 2)
+       switch (Phase)
-        {
+         {
-                BasePtr = copy_buff;
+         case SPACES:
-                Phase = SPACES;
+           if(isspace(*WordPtr))                  /* skip leading spaces */
-                term = ' ';
+             WordPtr++;
-                done_word = 0;
+           else
-                chars_seen = 0;
+             Phase = CHARS;
-                while (*WordPtr && !done_word && comment < 2)
+           break;
-                {
+         case CHARS:
-                        switch (Phase)
+           if(!escape && *WordPtr == '\\')
-                        {
+             {
-                        case SPACES:
+             escape = 1;
-                                if (isspace (*WordPtr)) /* skip leading spaces */
+             WordPtr ++;
-                                        WordPtr++;
+             }
-                                else
+           else
-                                        Phase = CHARS;
+             {
-                                break;
+             if(term==' ' && !escape && (*WordPtr=='"' || *WordPtr == '\'') )
-                        case CHARS:
+               {              /* sigle or double quotes ? */
-                                if (!escape && *WordPtr == '\\')
+               term = *WordPtr++;
-                                {
+               chars_seen = 1;
-                                        escape = 1;
+               }
-                                        WordPtr++;
+             else
-                                }
+               {
-                                else
+               /* handle ordinary chars */
-                                {
+               if(!escape && term==' ' && WordPtr[0]=='#')
-                                        if (term == ' ' && !escape &&
+                 {
-                                            (*WordPtr == '"' || *WordPtr == '\''))
+                 comment=2;
-                                        { /* sigle or double quotes ? */
+                 done_word = chars_seen; /* comment is appended to valid chars */
-                                                term = *WordPtr++;
+                 WordPtr++;
-                                                chars_seen = 1;
+                 }
-                                        }
+               else if (!escape && term == ' ' && WordPtr[0]=='-')
-                                        else
+                 {
-                                        {
+                 comment++;
-                                                /* handle ordinary chars */
+                 WordPtr++;
-                                                if (!escape && term == ' ' &&
+                 if(comment==2)
-                                                    WordPtr[0] == '#')
+                   done_word = chars_seen; /* comment is appended to valid chars */
-                                                {
+                 }
-                                                        comment = 2;
+               else if ((*WordPtr=='\r') ||
-                                                        done_word =
+                        (*WordPtr=='\n') ||
-                                                            chars_seen; /* comment is appended
+                        (!escape && (*WordPtr == term)))
-                                                                           to valid chars */
+                 {
-                                                        WordPtr++;
+                 if (comment==1)
-                                                }
+                   *BasePtr++ = '-';
-                                                else if (
+                 comment = 0;
-                                                    !escape && term == ' ' &&
+                 Phase = SPACES;
-                                                    WordPtr[0] == '-')
+                 *BasePtr = '\0';
-                                                {
+                 done_word = 1;
-                                                        comment++;
+                 WordPtr++;
-                                                        WordPtr++;
+                 }
-                                                        if (comment == 2)
+               else
-                                                                done_word =
+                 {
-                                                                    chars_seen; /* comment is
+                 if(escape)
-                                                                                   appended to
+                   *BasePtr++ = '\\';
-                                                                                   valid chars
+                 if (comment==1)
-                                                                                 */
+                   *BasePtr++ = '-';
-                                                }
+                 chars_seen = 1;
-                                                else if (
+                 comment = 0;
-                                                    (*WordPtr == '\r') || (*WordPtr == '\n') ||
+                 escape = 0;
-                                                    (!escape && (*WordPtr == term)))
+                 *BasePtr++ = *WordPtr++;
-                                                {
+                 }
-                                                        if (comment == 1)
+               }
-                                                                *BasePtr++ = '-';
+             }
-                                                        comment = 0;
+            break;
-                                                        Phase = SPACES;
+            } /* switch */
-                                                        *BasePtr = '\0';
+          } /* while */
-                                                        done_word = 1;
+          *BasePtr = '\0';
-                                                        WordPtr++;
+            /* make_string now performs an expand_string call */
-                                                }
+          if(chars_seen)
-                                                else
+              {
-                                                {
+              argv[argc++] = make_string(copy_buff,cmd_first,cmd_last);
-                                                        if (escape)
+             }
-                                                                *BasePtr++ = '\\';
-                                                        if (comment == 1)
+       }
-                                                                *BasePtr++ = '-';
+   * pargc = argc;
-                                                        chars_seen = 1;
+   free(copy_buff);
-                                                        comment = 0;
-                                                        escape = 0;
+   return (OKCMD);
-                                                        *BasePtr++ = *WordPtr++;
+   }
-                                                }
-                                        }
+/********************************* executes the command from stdin or a do file **************************/
-                                }
-                                break;
+int ExecuteCommand (FILE * CmdFile,int nArgs, char * Args[])
-                        } /* switch */
+   {
-                }         /* while */
+   char Buff[PATHLENGTH];
-                *BasePtr = '\0';
+   int  i, Status;
-                /* make_string now performs an expand_string call */
+   char * p;
-                if (chars_seen)
+   int    argc;
-                {
+   char * argv[WORDSINLINE];
-                        argv[argc++] = make_string (copy_buff, cmd_first, cmd_last);
+   struct str * cmd_first, * cmd_last;
-                }
+   cmd_first = NULL;
-        }
+   cmd_last  = NULL;
-        *pargc = argc;
-        free (copy_buff);
-        return (OKCMD);
+   if(!CmdFile || feof(CmdFile))
-}
+     return(QUITCMD);
-/********************************* executes the command from stdin or a do file
+   p=fgets(Buff,PATHLENGTH-1,CmdFile);                                    /* read the command from the input stream */
- * **************************/
+   argc=0;                                    /* place the command in the command structure */
+   if(p==NULL || *Buff=='\0')
-int ExecuteCommand (FILE *CmdFile, int nArgs, char *Args[])
+     return(OKCMD);
-{
-        char Buff[PATHLENGTH];
+   /* convert control codes to spaces */
-        int i, Status;
+   i=0;
-        char *p;
+   while(Buff[i]) {
-        int argc;
+     if (Buff[i]<' ')
-        char *argv[WORDSINLINE];
+       Buff[i]=' ';
-        struct str *cmd_first, *cmd_last;
+     i++;
-        cmd_first = NULL;
+     }
-        cmd_last = NULL;
+   FindWords (Buff,&argc,argv, nArgs,Args,&cmd_first,&cmd_last);                                   /* split off the words and save in structure */
-        if (!CmdFile || feof (CmdFile))
+   if (1 || CmdFile != stdin) {
-                return (QUITCMD);
+     printf("-- ");
+     for(i=0;i<argc;i++)
-        p = fgets (Buff, PATHLENGTH - 1, CmdFile); /* read the command from the input stream */
+      printf("%s ",ISNULLSTR(argv[i])?"\"\"":argv[i]); /* log the command word by word if its not given interactively */
-        argc = 0; /* place the command in the command structure */
+     printf("\n"); /*  */
-        if (p == NULL || *Buff == '\0')
+     }
-                return (OKCMD);
+/* the code below is not as helpful as it seems . Moved recognizer for comments into
+   Execute as the comments can appear at any point on the command line */
-        /* convert control codes to spaces */
+/*   if (argc ==0 ||
-        i = 0;
+       argv[0][0] == '-' ||
-        while (Buff[i])
+       argv[0][0] == '#') */
-        {
+   if(argc==0)
-                if (Buff[i] < ' ')
+     {
-                        Buff[i] = ' ';
-                i++;
+/* deallocate any previous structures */
-        }
+     free_strings(&cmd_first,&cmd_last);
+     return (OKCMD) ; /* comment or a null string */
-        FindWords (Buff, &argc, argv, nArgs, Args, &cmd_first, &cmd_last); /* split off the
+     }
-                                                                              words and save in
-                                                                              structure */
+   Status = Execute(argc,argv,TopMenu);                            /* pass the command through the top-level menu */
-        if (1 || CmdFile != stdin)
+   switch (Status) {
-        {
+     case UNKNOWNCMD :
-                printf ("-- ");
+       Log (LOG_ERROR, "# Unknown command\n");
-                for (i = 0; i < argc; i++)
+       break;
-                        printf (
+     case NARGS :
-                            "%s ",
+       Log (LOG_ERROR, "# Too few parameters\n");
-                            ISNULLSTR (argv[i]) ? "\"\""
+       break;
-                                                : argv[i]); /* log the command word by word if
+     case FAILED     :
-                                                               its not given interactively */
+       Log (LOG_ERROR, "# Problem with command\n");
-                printf ("\n");                              /*  */
+       break;
-        }
+     };
-        /* the code below is not as helpful as it seems . Moved recognizer for comments into
-           Execute as the comments can appear at any point on the command line */
+   if (Status !=OKCMD) {
-        /*   if (argc ==0 ||
+     Log(LOG_ERROR,"-- ? ");
-               argv[0][0] == '-' ||
+     for (i=0; i < argc; i++)     /*    display offending command */
-               argv[0][0] == '#') */
+       Log (LOG_ERROR,  " %s", ISNULLSTR(argv[i])?"\"\"":argv[i]);
-        if (argc == 0)
-        {
+     Log(LOG_ERROR,"\n");
-                /* deallocate any previous structures */
-                free_strings (&cmd_first, &cmd_last);
+     };
-                return (OKCMD); /* comment or a null string */
-        }
+/* deallocate any previous structures */
+   free_strings(&cmd_first,&cmd_last);
-        Status =
-            Execute (argc, argv, TopMenu); /* pass the command through the top-level menu */
-        switch (Status)
+   return(Status);
-        {
+   }
-        case UNKNOWNCMD:
-                Log (LOG_ERROR, "# Unknown command\n");
+/********************************* Execute a command string ******************************************/
-                break;
+int ExecuteString (char * commandstring , int nArgs, char * Args[]) {
-        case NARGS:
+  int argc =0;
-                Log (LOG_ERROR, "# Too few parameters\n");
+  char * argv[WORDSINLINE];
-                break;
+  int     Status = 0;
-        case FAILED:
-                Log (LOG_ERROR, "# Problem with command\n");
+  struct str * cmd_first, * cmd_last;
-                break;
+  cmd_first = NULL;
-        };
+  cmd_last  = NULL;
+  FindWords (commandstring,&argc,argv, nArgs,Args,&cmd_first,&cmd_last);                                   /* split off the words and save in structure */
-        if (Status != OKCMD)
+  Status = Execute(argc,argv,TopMenu);                            /* pass the command through the top-level menu */
-        {
+/* deallocate any previous structures */
-                Log (LOG_ERROR, "-- ? ");
+  free_strings(&cmd_first,&cmd_last);
-                for (i = 0; i < argc; i++) /*    display offending command */
+  return(Status);
-                        Log (LOG_ERROR, " %s", ISNULLSTR (argv[i]) ? "\"\"" : argv[i]);
+  }
-                Log (LOG_ERROR, "\n");
-        };
-        /* deallocate any previous structures */
-        free_strings (&cmd_first, &cmd_last);
+/********************************* A parser for the '*.do files ******************************************/
-        return (Status);
+static int Depth=0;
-}
+#define MAXDEPTH 10                    /* maximum depth of 'do' files */
+#define MAXARGV  10
-/********************************* Execute a command string
+int ParseFile (FILE * CmdFile,int nArgs,char * Args[])
- * ******************************************/
+   {
-int ExecuteString (char *commandstring, int nArgs, char *Args[])
+   int     Status = 0;
-{
+   char * argp[MAXARGV];
-        int argc = 0;
+   char ** argp_prev;
-        char *argv[WORDSINLINE];
+   int     nArgs_prev;
-        int Status = 0;
+   int i;
+/* diagnosis */
-        struct str *cmd_first, *cmd_last;
+   if ( nArgs > MAXARGV )
-        cmd_first = NULL;
+     nArgs = MAXARGV;
-        cmd_last = NULL;
+   if ( nArgs < 0 )
-        FindWords (
+     nArgs = 0;
-            commandstring, &argc, argv, nArgs, Args, &cmd_first, &cmd_last); /* split off the
+/* belt and braces null check */
-                                                                                words and save
+   if(!CmdFile)
-                                                                                in structure */
+     return(FAILED);
-        Status =
-            Execute (argc, argv, TopMenu); /* pass the command through the top-level menu */
+   for(i=0;i<MAXARGV;i++) {
-                                           /* deallocate any previous structures */
-        free_strings (&cmd_first, &cmd_last);
+     if (i < nArgs)
-        return (Status);
+       argp[i] = strdup(Args[i]);
-}
+     else
+       argp[i] = NULL;
-/********************************* A parser for the '*.do files
- * ******************************************/
-static int Depth = 0;
+     /* printf("Arg [%2d]='%s'\n",i,argp[i]);  */
-#define MAXDEPTH 10 /* maximum depth of 'do' files */
-#define MAXARGV 10
+     }
-int ParseFile (FILE *CmdFile, int nArgs, char *Args[])
+   nArgs_prev = yy_nArgs;
-{
+   argp_prev  = yy_Args;
-        int Status = 0;
+   yy_nArgs = nArgs;
-        char *argp[MAXARGV];
+   yy_Args  = argp;
-        char **argp_prev;
-        int nArgs_prev;
+   Depth ++;                                 /* keep a count of recursion depth */
-        int i;
+   printf("-- Command file nesting level = %d\n",Depth);
-        /* diagnosis */
+   if (Depth > MAXDEPTH)
-        if (nArgs > MAXARGV)
+      {
-                nArgs = MAXARGV;
+      Log (LOG_ERROR, "Recursive call of files is greater than %d\n", MAXDEPTH);
-        if (nArgs < 0)
+      Depth--;
-                nArgs = 0;
+      return (FAILED);
-        /* belt and braces null check */
-        if (!CmdFile)
+      }
-                return (FAILED);
+   while(Status == OKCMD )                    /* execute the command from do file input stream */
+      Status = ExecuteCommand(CmdFile, nArgs, argp);
-        for (i = 0; i < MAXARGV; i++)
+  Depth--;
-        {
+  yy_nArgs = nArgs_prev;
-                if (i < nArgs)
+  yy_Args  = argp_prev;
-                        argp[i] = strdup (Args[i]);
+  for(i=0;i<MAXARGV;i++)
-                else
+     if (argp[i]) {
-                        argp[i] = NULL;
+       free(argp[i]);
+       argp[i] = NULL;
-                /* printf("Arg [%2d]='%s'\n",i,argp[i]);  */
+       }
-        }
+   return(Status);
-        nArgs_prev = yy_nArgs;
+   }
-        argp_prev = yy_Args;
-        yy_nArgs = nArgs;
-        yy_Args = argp;
-        Depth++; /* keep a count of recursion depth */
-        printf ("-- Command file nesting level = %d\n", Depth);
-        if (Depth > MAXDEPTH)
-        {
-                Log (LOG_ERROR, "Recursive call of files is greater than %d\n", MAXDEPTH);
-                Depth--;
-                return (FAILED);
-        }
-        while (Status == OKCMD) /* execute the command from do file input stream */
-                Status = ExecuteCommand (CmdFile, nArgs, argp);
-        Depth--;
-        yy_nArgs = nArgs_prev;
-        yy_Args = argp_prev;
-        for (i = 0; i < MAXARGV; i++)
-                if (argp[i])
-                {
-                        free (argp[i]);
-                        argp[i] = NULL;
-                }
-        return (Status);
-}
 /*********************************************************************************************************/

Subversion Repositories Vertical

(root)/branches/metal/cmdlib/cmdparse.c – Rev 2 → 11