Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

kom.c

Go to the documentation of this file.
00001 
00002 /*
00003  *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE
00004  *   CHECKED IT OUT USING THE COMMAND CHECKOUT.
00005  *
00006  *    $Id: kom_8c-source.html 2161 2006-05-19 16:55:03Z paulf $
00007  *
00008  *    Revision history:
00009  *     $Log$
00009  *     Revision 1.1  2006/05/19 16:55:02  paulf
00009  *     first inclusion
00009  *
00010  *     Revision 1.2  2001/10/05 20:42:15  dietz
00011  *     Increased MAXCRD to 1024 (was 512)
00012  *
00013  *     Revision 1.1  2000/02/14 18:51:48  lucky
00014  *     Initial revision
00015  *
00016  *
00017  */
00018 
00019 /*
00020  * kom.c : Simple positional command parser.
00021  *
00022  *$ 91May07 CEJ Version 1.0
00023  *$ 93Oct03 CEJ Added k_put routine.
00024  *$ 95Oct18 LDD Created kom.h to house function prototypes.
00025  *              Explicitly declared return types for all functions.
00026  */
00027 /*********************C O P Y R I G H T   N O T I C E ***********************/
00028 /* Copyright 1991 by Carl Johnson.  All rights are reserved. Permission     */
00029 /* is hereby granted for the use of this product for nonprofit, commercial, */
00030 /* or noncommercial publications that contain appropriate acknowledgement   */
00031 /* of the author. Modification of this code is permitted as long as this    */
00032 /* notice is included in each resulting source module.                      */
00033 /****************************************************************************/
00034 
00035 #include <stdio.h>
00036 #include <stdlib.h>
00037 #include <string.h>
00038 #include <kom.h>
00039 
00040 #define MAXCRD 1024
00041 static struct k_buf {
00042         FILE *fid;
00043         int ncrd;               /* bytes in command             */
00044         int istr;               /* index of current string      */
00045         int icrd;               /* scan pointer                 */
00046         int ierr;               /* error if non-zero            */
00047         char crd[MAXCRD];       /* command buffer               */
00048         char csav[MAXCRD];      /* last command read            */
00049 } ;
00050 
00051 #define MAXBUF 4
00052 struct k_buf com = {0L, 0, 0, 0, 0, "Virgin", "Virgin"};
00053 struct k_buf Kbuf[MAXBUF];
00054 int Nbuf = 0;
00055 
00056 
00057 /*
00058  **** k_open : open new file for k-system input.  For now only one file
00059  *              can be open at a time, but it should be straight foward to add
00060  *              recursion capabitity using a stack in the com area.
00061  */
00062 int k_open( char *name )
00063 {
00064         if(Nbuf < MAXBUF && com.fid) {
00065                 Kbuf[Nbuf++] = com;
00066                 com.fid = 0;
00067         }
00068         if(com.fid)
00069                 return(0);
00070 /*      if(!strcmp(name, "term"))
00071                 com.fid = stdin;
00072         else                                                    */
00073                 com.fid = fopen(name, "r");
00074         if(com.fid)
00075                 return(Nbuf+1);
00076         return(0);
00077 
00078 }
00079 /*
00080  **** k_close : close current file
00081  */
00082 int k_close( void )
00083 {
00084         if(com.fid){
00085                 if(com.fid != stdin)
00086                         fclose(com.fid);
00087                 com.fid = 0L;
00088         }
00089         if(Nbuf > 0) {
00090                 com = Kbuf[--Nbuf];
00091                 return Nbuf+1;
00092         }
00093         return(0);
00094 
00095 }
00096 
00097 /*
00098  **** k_get : Return pointer to current card.
00099  */
00100 char *k_get( void )
00101 {
00102         return com.crd;
00103 }
00104 
00105 /*
00106  **** k_dump : Print last card read.
00107  */
00108 void k_dump( void )
00109 {
00110         printf("%s\n", com.crd);
00111 }
00112 
00113 /*
00114  **** k_err : return last error code and clear
00115  */
00116 int k_err( void )
00117 {
00118         int jerr;
00119 
00120         jerr = com.ierr;
00121         com.ierr = 0;
00122         return(jerr);
00123 }
00124 
00125 /*
00126  * k_int : Parce next token as integer.
00127  */
00128 int k_int( void )
00129 {
00130         int ival;
00131         char *s;
00132 
00133         s = k_str();
00134         if(!s) {
00135                 com.ierr = -1;
00136                 return(0);
00137         }
00138         ival = atoi(s);
00139         if(ival == 0 && *s != '0') {
00140                 com.ierr = -2;
00141                 return(0);
00142         }
00143         return(ival);
00144 }
00145 
00146 /*
00147  * k_its : Compare string from last token to given command.
00148  */
00149 int k_its(char *c)
00150 {
00151         char *s;
00152 
00153         s = &com.crd[com.istr];
00154         while(*c == *s) {
00155                 if(*s == '\0')
00156                         return(1);
00157                 c++;
00158                 s++;
00159         }
00160         return(0);
00161 }
00162 
00163 /*
00164  * k_long : Return next token as a long integer.
00165  */
00166 long k_long( void )
00167 {
00168         long lval;
00169         char *s;
00170 
00171         s = k_str();
00172         if(!s) {
00173                 com.ierr = -1;
00174                 return(0L);
00175         }
00176         lval = atol(s);
00177         if(lval == 0 && *s != '0') {
00178                 com.ierr = -2;
00179                return(0L);
00180         }
00181         return(lval);
00182 }
00183 
00184 /*
00185  **** k_put : insert command line into buffer
00186  */
00187 int k_put(char *crd)
00188  {
00189         int i, n;
00190 
00191         strcpy(com.crd, crd);
00192         com.ncrd = strlen(crd);
00193         if(com.ncrd && com.crd[com.ncrd-1] == '\n')
00194                 com.crd[--com.ncrd] = 0;
00195         if(!com.ncrd) {
00196                 com.ncrd = 1;
00197                 com.crd[0] = ' ';
00198                 com.crd[1] = 0;
00199         }
00200         com.istr = 0;
00201         com.icrd = 0;
00202         com.ierr = 0;
00203         n = 1;
00204         for(i=0; i<com.ncrd; i++) {
00205                 if(com.crd[i] == '\t')
00206                         com.crd[i] = ' ';
00207                 if(com.crd[i] != ' ')
00208                         n = i + 1;
00209         }
00210         com.ncrd = n;
00211         com.crd[n] = 0;
00212         strcpy(com.csav, com.crd);
00213         return(com.ncrd);
00214 }
00215 
00216 /*
00217  **** k_rd : read command line into buffer
00218  */
00219 int k_rd( void )
00220 {
00221         FILE *fid;
00222         extern struct k_buf com;
00223         int n;
00224         int i;
00225 
00226         fid = com.fid;
00227         if(com.fid) {
00228                 if(!fgets(com.crd, MAXCRD-1, fid))
00229                         if(feof(fid))
00230                                 return(0);
00231         } /*else {
00232                 if(!gets(com.crd))
00233                         return(0);
00234         }                                 */
00235         com.ncrd = strlen(com.crd);
00236         if(com.ncrd && com.crd[com.ncrd-1] == '\n')
00237                 com.crd[--com.ncrd] = 0;
00238         if(!com.ncrd) {
00239                 com.ncrd = 1;
00240                 com.crd[0] = ' ';
00241                 com.crd[1] = 0;
00242         }
00243         com.istr = 0;
00244         com.icrd = 0;
00245         com.ierr = 0;
00246         n = 1;
00247         for(i=0; i<com.ncrd; i++) {
00248                 if(com.crd[i] == '\t')
00249                         com.crd[i] = ' ';
00250                 if(com.crd[i] != ' ')
00251                         n = i + 1;
00252         }
00253         com.ncrd = n;
00254         com.crd[n] = 0;
00255         strcpy(com.csav, com.crd);
00256         return(com.ncrd);
00257 }
00258 
00259 /*
00260  **** k_com : returns last command line read
00261  */
00262 char *k_com( void )
00263 {
00264         return com.csav;
00265 }
00266 
00267 /*
00268  **** k_str() : Return next token as a pointer to string.
00269  */
00270 char *k_str( void )
00271 {
00272         int state;
00273         int i;
00274 
00275         state = 1;
00276         for(i=com.icrd; i<com.ncrd; i++) {
00277                 switch(state) {
00278                 case 1: /* Looking for first non-blank          */
00279                         if(com.crd[i] == ' ' || com.crd[i] == '\t')
00280                                 break;
00281                         if(com.crd[i] == '"') {
00282                                 state = 3;
00283                                 com.istr = i + 1;
00284                                 break;
00285                         }
00286                         state = 2;
00287                         com.istr = i;
00288                         break;
00289                 case 2: /* Looking for end of normal string */
00290                         if(com.crd[i] == ' ' || com.crd[i] == '\t') {
00291                                 com.crd[i] = 0;
00292                                 com.icrd = i + 1;
00293                                 return(&com.crd[com.istr]);
00294                         }
00295                         break;
00296                 case 3: /* Quoted string */
00297                         if(com.crd[i] == '"') {
00298                                 com.crd[i] = 0;
00299                                 com.icrd = i + 1;
00300                                 return(&com.crd[com.istr]);
00301                         }
00302                         break;
00303                 }
00304         }
00305         if(state == 2) {
00306                 com.crd[com.ncrd] = 0;
00307                 com.icrd = com.ncrd;
00308                 return(&com.crd[com.istr]);
00309         }
00310         com.ierr = -17;
00311         return( (char *) 0 );
00312 }
00313 
00314 /*
00315  **** k_val() Return next token as a double real
00316  */
00317 double k_val( void )
00318 {
00319         double val;
00320         char *s;
00321 
00322         s = k_str();
00323         if(!s) {
00324                 com.ierr = -1;
00325                 return(0.0);
00326         }
00327         val = atof(s);
00328         return(val);
00329 }

Generated on Tue May 6 09:16:03 2003 for Earthworm Libs by doxygen1.3-rc3