/* * CDE - Common Desktop Environment * * Copyright (c) 1993-2012, The Open Group. All rights reserved. * * These libraries and programs are free software; you can * redistribute them and/or modify them under the terms of the GNU * Lesser General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) * any later version. * * These libraries and programs are distributed in the hope that * they will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public * License along with these libraries and programs; if not, write * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth * Floor, Boston, MA 02110-1301 USA */ /* $XConsortium: parser.c /main/8 1996/03/25 09:14:08 rswiston $ */ /***************************************************************************/ /* */ /* parser.c */ /* */ /***************************************************************************/ #ifdef _AIX #define _ILS_MACRO #endif /* _AIX */ #include #include #include #include #include "dtcreate.h" #include "parser.h" #include /*************************************************************************** * * Local procedure declarations * ***************************************************************************/ char ** GetKeywordValuePairs(char *, int *, int); FiletypeData ** GetFiletypeData(FILE *, char *, short *); char ** ProcessExecString(char *); int ProcessContents(FiletypeData *); Boolean IsLastSingle(char *); /*************************************************************************** * * Extern variable declarations * ***************************************************************************/ /*************************************************************************** * * Global variable declarations * ***************************************************************************/ /* Action Keyword Table */ char keywordDB[][30] = { "ACTION" , "ICON" , "EXEC_STRING" , "DESCRIPTION" , "TYPE" , "WINDOW_TYPE" , "ARG_TYPE" , "LABEL" , '\0' , }; /* Max Number of fields in Action Keyword Table */ #define MAX_NUM_ACTION_FIELDS 8 /* Filetype Keyword Table */ char FiletypekeywordDB[][30] = { "DATA_ATTRIBUTES" , "ICON" , "DESCRIPTION" , "EXEC_STRING" , "NAME_PATTERN" , "PATH_PATTERN" , "MODE" , "CONTENT" , "ACTIONS" , "DATA_ATTRIBUTES_NAME" , "DATA_CRITERIA" , "WINDOW_TYPE" , "ACTION" , "ARG_TYPE" , "MAP_ACTION" , "TYPE" , "LABEL" , '\0' , }; /* Max Number of fields in Filetype Keyword Table */ #define MAX_NUM_FILETYPE_FIELDS 17 char *args[3],*fline; int flinesize=0; static int state = 0; /***************************************************************** ** ** ** GetActionData(FILE *fp, ActionData *) ** ** ** ** Description: Parses the action file and fills the data in the** ** pointer pointing to the ActionData structure ** ** passed as input. ** ** ** ** Input : Filepointer that points to the ActionFile and, ** ** a pointer to the ActionData structure. ** ** ** ** Output : 0 (No error). ** ** 1 (error). ** ** ** ** references : dtcreate.h, parser.h, and dtcreate spec. ** ** ** ******************************************************************/ int GetActionData(FILE *fp, ActionData *ActionDataptr) { int rc,manflds=0,len,first=TRUE,lastfld=0,fldid=-1; char linebuf[1024],**wordPairs,**execstr; /* reset the read pointer to zero byte for fp */ rewind(fp); /* Initialize the ActionData structure passed */ if(ActionDataptr) memset(ActionDataptr, 0,sizeof(ActionData)); else { #ifdef DEBUG printf("ActionDataptr is NULL\n"); #endif return 1; } /* initialize the linebuf with NULL's */ bzero(linebuf,sizeof(linebuf)); while (fgets (linebuf, sizeof (linebuf)-1, fp)) { /* skip the complete line if it starts with a '{' or a comment ('#') */ if(linebuf[0] == '{' || linebuf[0] == '#') continue; /* If the first character is '}' reached the end of Action Stanza so quit */ if(linebuf[0] == '}') break; len = strlen (linebuf); if (linebuf[len-1] == '\n') linebuf[len-1] = '\0'; /* Get the keyword and value pair from the string linebuf */ /* On return, wordPairs[0] = keyword like ICON and wordPairs[1] = value for the keyword */ if( (wordPairs = GetKeywordValuePairs(linebuf,&fldid,ACTION_TABLE)) != NULL) { if( first && strcmp(wordPairs[0],"ACTION") ) { #ifdef DEBUG printf("first && strcmp(wordPairs[0],ACTION)\n"); #endif return 1; } else first = FALSE; /* Update the mandatory fields counter */ if( !strcmp(wordPairs[0],"TYPE") || !strcmp(wordPairs[0],"EXEC_STRING") || !strcmp(wordPairs[0],"WINDOW_TYPE") ) manflds++; if( !strcmp(wordPairs[0],"WINDOW_TYPE") ) { if( !strcmp(wordPairs[1],"PERM_TERMINAL") ) ActionDataptr->fsFlags |= CA_WT_PERMTERM; if( !strcmp(wordPairs[1],"TERMINAL") ) ActionDataptr->fsFlags |= CA_WT_TERM; if( !strcmp(wordPairs[1],"NO_STDIO") ) ActionDataptr->fsFlags |= CA_WT_XWINDOWS; } if( !strcmp(wordPairs[0],"ARG_TYPE") ) ActionDataptr->fsFlags |= CA_DF_ONLYFTFILES; /* if linebuf does not contain the keyword then everything in wordPairs[0],else, wordPairs[0] contains the keyword and wordpairs[1] contains the value. */ if( wordPairs && wordPairs[0] && !wordPairs[1]) { /* fldid is returned by the GetKeywordValuePairs function. This id determines which field of the ActionDataptr will have the value. Please see KeywordDB array in parser.h for more details. */ switch(fldid) { case 7: /* next line for action_name */ ActionDataptr->pszName=wordPairs[0]; break; case 1: /* next line for action_icon_name */ ActionDataptr->pszIcon=wordPairs[0]; break; case 2 : /* next line for exec_string */ ActionDataptr->pszCmd=wordPairs[0]; break; case 3: /* next line for action_help_text */ ActionDataptr->pszHelp=wordPairs[0]; break; default: break; } } else if(wordPairs && wordPairs[1]) { if(fldid >= 0 && fldid <=2) state = 0; /* for fldid see the comments above */ switch(fldid) { case 7: /* first line for action_name */ ActionDataptr->pszName=wordPairs[1]; break; case 1: /* first line for action_icon_name */ ActionDataptr->pszIcon=wordPairs[1]; break; case 2 : /* first line for exec_string */ ActionDataptr->pszCmd=wordPairs[1]; break; case 3: /* first line for action_help_text */ state = HELP_TEXT; ActionDataptr->pszHelp=wordPairs[1]; break; default: state=0;break; } } /* reset the linebuf to NULL's */ bzero(linebuf,sizeof(linebuf)); } } state=0; /* Done with retrieving Action Data */ /* Check if we got all the mandatory fields data */ if(manflds != 3) { #ifdef DEBUG printf("if(manflds != 3)\n"); #endif return 1; } else { /* Everything looks right so process the exec_string */ if( !(execstr = ProcessExecString(ActionDataptr->pszCmd)) ) { ActionDataptr->pszCmd = NULL; ActionDataptr->pszPrompt = 0; } else { ActionDataptr->pszCmd = execstr[0]; ActionDataptr->pszPrompt = execstr[1]; free(execstr); } /* Got the ActionData,so, go get the FiletypeData */ ActionDataptr->papFiletypes = (FiletypeData **) GetFiletypeData(fp,(char *)(ActionDataptr->pszCmd), (short *)&(ActionDataptr->cFiletypes) ); if( !ActionDataptr->papFiletypes && ActionDataptr->cFiletypes > 0) { #ifdef DEBUG printf("!ActionDataptr->papFiletypes && ActionDataptr->cFiletypes > 0)\n"); #endif return(1); /* return 1 if error */ } else return(0); /* return 0 if no error */ } } /***************************************************************** ** ** ** GetFiletypeData(FILE *fp, char *pszOpenCmd) ** ** ** ** Description: Parses the action file and returns a pointer ** ** that points to the data in the form of ** ** FiletypeData structure (defined in dtcreate.h). ** ** ** ** Input : Filepointer that points to the ActionFile, and, ** ** a char pointer to the exec_string of the ** ** ActionData structure as obtained in the GetAc- ** ** -tionData function call. ** ** ** ** Output : Pointer to an array of FiletypeData structures ** ** containing data for all the Filetypes,and,no of ** ** file types. ** ** ** ** references : dtcreate.h, parser.h, and dtcreate spec. ** ** ** ******************************************************************/ FiletypeData ** GetFiletypeData(FILE *fp, char *pszOpenCmd, short *nftypes) { int manflds=0,len,nfiletypes,previous=0,lastfld=0,fldid; char linebuf[1024],**wordPairs,**execstr; FiletypeData **ppFiletypeData,**ppnewFiletypeData; wordPairs=0; ppFiletypeData=0; nfiletypes=0; /* Initialize the linebuf */ bzero(linebuf,sizeof(linebuf)); while (fgets (linebuf, sizeof (linebuf)-1, fp)) { /* If begin of a stanza skip and continue */ if(linebuf[0] == '{') { continue; } /* skip the rest of the line if a comment found */ if(linebuf[0] == '#') continue; /* If end of a stanza check if all the mandatory fields are there */ if( linebuf[0] == '}' ) { /* Check for atleast one field in DATA_ATTRIBUTES stanza */ if( previous == DATA_ATTRIBUTES && manflds != 1 ) { printf("Error in DATA_ATTR stanza of the FiletypeData\n"); return NULL; } /* Check for atleast one field in DATA_CRITERIA stanza */ else if( previous == DATA_CRITERIA && manflds != 1 ) { printf("Error in DATA_CRITERIA stanza of the FiletypeData\n"); return NULL; } /* Check for atleast two fields in ACTION_OPEN or ACTION_PRINT stanza */ else if( (previous == ACTION_OPEN || previous == ACTION_PRINT) ) { if( manflds != 4) { printf("Error in ACTION_OPEN/PRINT stanza of the FiletypeData\n"); return NULL; } } /* Check for atleast three fields in ACTION_PRINT_FTYPE stanza */ else if( previous == ACTION_PRINT_FTYPE && manflds != 3 ) { printf("Error in ACTION_PRINT_FTYPE stanza of the FiletypeData\n"); return NULL; } continue; } len = strlen (linebuf); if (linebuf[len-1] == '\n') linebuf[len-1] = '\0'; if( (wordPairs = GetKeywordValuePairs(linebuf,&fldid,FILETYPE_TABLE)) != NULL) { if( !strcmp(wordPairs[0],"DATA_ATTRIBUTES") ) { /* first filetype */ if( previous == 0 ) { /* Allocate a filetypedata pointer to an array of filetypedata records */ if( !ppFiletypeData) { if( (ppFiletypeData = (FiletypeData **)calloc(1,sizeof(FiletypeData *))) == NULL ) { printf("\n Cannot allocate memory\n"); return NULL; } /* Allocate a filetypedata record */ else { if( (ppFiletypeData[nfiletypes] = (FiletypeData *)calloc(1,sizeof(FiletypeData)) ) == NULL ) { printf("\n Cannot allocate memory\n"); return NULL; } } } ppFiletypeData[nfiletypes]->pszOpenCmd = pszOpenCmd; previous = DATA_ATTRIBUTES; manflds=0; } else if(previous == ACTION_OPEN || previous == ACTION_PRINT) { /* New filetypedata started so allocate a new filetypedata ptr */ if( (ppnewFiletypeData = (FiletypeData **)realloc((FiletypeData *)ppFiletypeData, nfiletypes+2 * sizeof(FiletypeData *))) == NULL ) { printf("\n Cannot allocate memory\n"); return NULL; } else if(ppFiletypeData) { ppFiletypeData=ppnewFiletypeData; /* Process the contents field if any */ if(ProcessContents((FiletypeData *)ppFiletypeData[nfiletypes]) < 0 ) { printf("\n Error in Contents Data\n"); return NULL; } /* Everything looks right so process the exec_string */ if( !(execstr = ProcessExecString((char *)ppFiletypeData[nfiletypes]->pszPrintCmd)) ) ppFiletypeData[nfiletypes]->pszPrintCmd=NULL; else { ppFiletypeData[nfiletypes]->pszPrintCmd=execstr[0]; free(execstr); } nfiletypes++; /* Allocate a new filetypedata record */ if( (ppFiletypeData[nfiletypes] = (FiletypeData *)calloc(1,sizeof(FiletypeData)) ) == NULL ) { printf("\n Cannot allocate memory\n"); return NULL; } ppFiletypeData[nfiletypes]->pszOpenCmd = pszOpenCmd; previous = DATA_ATTRIBUTES; manflds=0; } } else { printf("Error in filetypedata \n"); return NULL; } } else if( !strcmp(wordPairs[0],"DATA_CRITERIA") ) { if( previous == DATA_ATTRIBUTES ) { previous = DATA_CRITERIA; manflds=0; } else { printf("Error in filetypedata \n"); return NULL; } } else if( !strcmp(wordPairs[0],"ACTION") && !strcmp(wordPairs[1],"Open") ) { if( previous == DATA_CRITERIA ) { previous = ACTION_OPEN; manflds=0; } else { printf("Error in filetypedata \n"); return NULL; } } else if( !strcmp(wordPairs[0],"ACTION") && strcmp(wordPairs[1],"Open") && strcmp(wordPairs[1], "Print") ) { if( previous == ACTION_OPEN ) { previous = ACTION_PRINT_FTYPE; manflds=0; } else { printf("Error in filetypedata \n"); return NULL; } } else if( !strcmp(wordPairs[0],"ACTION") && !strcmp(wordPairs[1],"Print") ) { if( previous == ACTION_PRINT_FTYPE ) { previous = ACTION_PRINT; manflds=0; } else { printf("Error in filetypedata \n"); return NULL; } } /* update mandatory fields counter */ if( previous == DATA_ATTRIBUTES && strcmp(wordPairs[0],"DATA_ATTRIBUTES") ) { if( !strcmp(wordPairs[0],"ACTIONS") ) manflds++; } else if( previous == DATA_CRITERIA ) { if( !strcmp(wordPairs[0],"DATA_ATTRIBUTES_NAME") ) manflds++; } else if( previous == ACTION_OPEN || previous == ACTION_PRINT ) { if( !strcmp(wordPairs[0],"ARG_TYPE") || !strcmp(wordPairs[0],"TYPE") || !strcmp(wordPairs[0],"MAP_ACTION") || !strcmp(wordPairs[0],"LABEL") ) manflds++; } else if( previous == ACTION_PRINT_FTYPE ) { if( !strcmp(wordPairs[0],"TYPE") || !strcmp(wordPairs[0],"WINDOW_TYPE") ) manflds++; } } if( wordPairs && !wordPairs[1] && wordPairs[0]) { switch(fldid) { case 0: /* next line for filetype_name */ ppFiletypeData[nfiletypes]->pszName=wordPairs[0]; break; case 1: /* next line for icon_name */ ppFiletypeData[nfiletypes]->pszIcon=wordPairs[0]; break; case 2 : /* next line for help_text */ ppFiletypeData[nfiletypes]->pszHelp=wordPairs[0]; break; case 3: /* next line for print_cmd */ ppFiletypeData[nfiletypes]->pszPrintCmd=wordPairs[0]; manflds++; break; case 4: /* next line for name_pattern or path_pattern */ ppFiletypeData[nfiletypes]->pszPattern=wordPairs[0]; break; case 5: /* next line for name_pattern or path_pattern */ ppFiletypeData[nfiletypes]->pszPattern=wordPairs[0]; break; case 6: /* next line for mode */ ppFiletypeData[nfiletypes]->pszPermissions=wordPairs[0]; break; case 7: /* next line for contents */ ppFiletypeData[nfiletypes]->pszContents=wordPairs[0]; break; default: break; } } else if(wordPairs && wordPairs[1]) { switch(fldid) { case 0: /* first line for filetype_name */ ppFiletypeData[nfiletypes]->pszName = wordPairs[1]; break; case 1: /* first line for icon_name */ ppFiletypeData[nfiletypes]->pszIcon=wordPairs[1]; break; case 2 : /* first line for help_text */ ppFiletypeData[nfiletypes]->pszHelp=wordPairs[1]; break; case 3: /* first line for print_cmd */ ppFiletypeData[nfiletypes]->pszPrintCmd=wordPairs[1]; manflds++; break; case 4: /* first line for name_pattern or path_pattern */ ppFiletypeData[nfiletypes]->pszPattern=wordPairs[1]; break; case 5: /* first line for name_pattern or path_pattern */ ppFiletypeData[nfiletypes]->pszPattern=wordPairs[1]; break; case 6: /* first line for mode */ ppFiletypeData[nfiletypes]->pszPermissions=wordPairs[1]; break; case 7: /* first line for contents */ ppFiletypeData[nfiletypes]->pszContents=wordPairs[1]; break; default: break; } } bzero(linebuf,sizeof(linebuf)); } /* end of while fgets */ /* Done with retrieving FiletypeData */ /* Check if we got all the mandatory fields data */ if( (previous == ACTION_OPEN && manflds != 4) || (previous == ACTION_PRINT && manflds != 4) ) return NULL; else if(ppFiletypeData) { /* Process Contents for the last file filetype if any */ if(ProcessContents((FiletypeData *)ppFiletypeData[nfiletypes]) < 0) { printf("\n Error in Contents Data\n"); return NULL; } /* Everything looks right so process the exec_string */ if(!(execstr = ProcessExecString((char *)ppFiletypeData[nfiletypes]->pszPrintCmd)) ) ppFiletypeData[nfiletypes]->pszPrintCmd=NULL; else ppFiletypeData[nfiletypes]->pszPrintCmd=execstr[0]; if( !ppFiletypeData[nfiletypes]) ppFiletypeData[nfiletypes] = 0; /* return number of filetypes */ *nftypes = nfiletypes+1; free(execstr); return ppFiletypeData; } else return NULL; } /***************************************************************** ** ** ** GetKeywordValuePairs(char *s, int *id, int table) ** ** ** ** Description: Parses the text string in *s and returns a ** ** pointer to two strings that are Keyword and ** ** values.However, it returns the complete string ** ** in the first pointer if keyword not found. ** ** ** ** Input : A character pointer pointing to text string. ** ** An integer pointer to return the field id. ** ** An integer value that determines which table to ** ** use (either ACTION_TABLE of FILETYPE_TABLE). ** ** see definitions in parser.h ** ** ** ** Output : pointer to two pointers pointing to text strings** ** fieldid in the id parameter. ** ** ** ** references : dtcreate.h, parser.h, and dtcreate spec. ** ** ** ******************************************************************/ char ** GetKeywordValuePairs(char *s, int *id, int table) { char *wordStart; static int fldid=-1; int idx; args[0] = args[1] = args[2] = NULL; /* Skip all leading spaces */ while (*s && isspace (*s)) ++s; /* Skip the complete line if a '#' character is found (comments) */ if (!*s || *s == '#') return NULL; wordStart = s; while (*s && *s != '#' && !isspace (*s)) ++s; if (!args[0]) { int szArgs0 = s - wordStart + 1; args[0] = (char *)malloc (szArgs0); if (!args[0]) return NULL; memset(args[0],0,szArgs0); } strncpy (args[0], wordStart, s - wordStart); args[0][s-wordStart] = '\0'; if (!args[1]) { int szArgs1 = strlen(s) + 1; args[1] = (char *)malloc (szArgs1); if (!args[1]) { if(args[0]) free(args[0]); return NULL; } memset(args[1],0,szArgs1); } /* Skip all leading spaces */ while (*s && isspace (*s)) ++s; strcpy (args[1], s); args[2]=NULL; /* Check for whether args[0] is a keyword or not */ idx=0; if( table == ACTION_TABLE ) { /* Check for keyword in keywordDB defined in parser.h */ while((strcmp(keywordDB[idx],"")) && (strcmp(args[0],keywordDB[idx])) ) idx++; if(idx >= 0 && idx < MAX_NUM_ACTION_FIELDS) fldid = idx; } else if( table == FILETYPE_TABLE ) { /* Check for keyword in FiletypekeywordDB defined in parser.h */ while((strcmp(FiletypekeywordDB[idx],"")) && (strcmp(args[0],FiletypekeywordDB[idx])) ) idx++; if(idx >= 0 && idx < MAX_NUM_FILETYPE_FIELDS) fldid = idx; } /* If no keyword found then keep the complete string in the first array */ if( (idx == MAX_NUM_ACTION_FIELDS && table == ACTION_TABLE) || (idx == MAX_NUM_FILETYPE_FIELDS && table == FILETYPE_TABLE) ) { char *temp4; if( (temp4 = (char *)realloc(args[0],strlen(args[0])+strlen(args[1])+2) ) == NULL ) { printf("Cannot Allocate memory\n"); return NULL; } args[0] = temp4; strcat(args[0]," "); strcat(args[0],args[1]); if(args[1]) { free(args[1]); args[1]=NULL; } if( IsLastSingle(args[0]) && args[0][strlen(args[0])-1] == '\\' ) args[0][strlen(args[0])-1] = '\0'; if( (temp4 = (char *)realloc(fline,flinesize+strlen(args[0])+1)) == NULL) { printf("Cannot Allocate memory\n"); return NULL; } strcat(temp4,args[0]); free(args[0]); args[0]=temp4; } *id = fldid; /* return field id */ if(args[1] && IsLastSingle(args[1]) && args[1][strlen(args[1])-1] == '\\') args[1][strlen(args[1])-1] = '\0'; if(args[0]) args[0][strlen(args[0])] = '\0'; if(args[1]) args[1][strlen(args[1])] = '\0'; if(args[0] && args[1]) { fline = args[1]; flinesize=strlen(fline); } if(!args[1] && args[0]) { fline = args[0]; flinesize=strlen(fline); } return args; } /***************************************************************** ** ** ** ProcessExecString(char *) ** ** ** ** Description: Parses the text string and returns two pointers,** ** the first pointing to cmd part (if any) ** ** the second pointing to prompt part (if any) ** ** of either the ActionData structure type or ** ** FiletypeData structure type. Please see ** ** dtcreate.h for the above mentioned datastructure** ** definitions and for the cmd and prompt fields ** ** ** ** Input : A character pointer that points to the complete ** ** text string comprising the command and arguments** ** and prompt (if any). ** ** ** ** Limitation : Supports only ONE prompt. ** ** ** ** Output : Pointer to 3-element result array from malloc, ** ** or NULL on error ** ** ** ** Assumptions: a) Arg fields start with a '%' character. ** ** b) Prompt string start and end with '"' chara- ** ** cter. Also, the prompt string comes after ** ** the Arg strings if any. ** ** ** ** references : dtcreate.h, parser.h, and dtcreate spec. ** ** ** ******************************************************************/ char ** ProcessExecString(char *cmd) { char *s1, *s2,*s3,*s4,*argbuf,**exec_args; int done=FALSE, argfound=FALSE,promptfound=FALSE; if (!cmd) { return((char **)NULL); } s1=s2=s3=s4=argbuf=NULL; exec_args = calloc(3, sizeof(char*)); if (!exec_args) return NULL; /* Allocate buffer for the cmd string */ exec_args[0] = (char *)calloc(1,strlen(cmd)+1); exec_args[1] = exec_args[2] = NULL; /* check if any Args present */ s1=cmd; while( !done ) { char *tmp; tmp=NULL; s4 = strstr(s1,"%Arg"); if(s4) { if ( (s4-s1) > 0 ) { strncat(exec_args[0],s1,(s4-s1)); exec_args[0][strlen(exec_args[0])] = '\0'; } s1 = s4; s2 = strchr(s1+1,'%'); /* at this point we got s1 to s2 covers the complete string between %'s */ if(argbuf) { free(argbuf); argbuf = NULL; } if(s2) { argbuf = (char *)calloc(1,(s2-s1)+2); strncpy(argbuf,s1,(s2-s1)+1); } else { strcat(exec_args[0],s1); done=TRUE; continue; } argbuf[strlen(argbuf)]='\0'; if( strncmp(argbuf,"%Arg_",5) && strncmp(argbuf,"%Args%",6) && strncmp(argbuf,"%Args\"",6) ) { strncat(exec_args[0],argbuf,strlen(argbuf)-1); exec_args[0][strlen(exec_args[0])] = '\0'; s1=s2; continue; } } else if (*s1) { strcat(exec_args[0],s1); if(argbuf) { free(argbuf); argbuf = NULL; } done = TRUE; continue; } else { done = TRUE; continue; } /* move s1 until a '_' or 's' */ tmp = strchr(argbuf,'_'); if(!tmp) tmp= strchr(argbuf,'s'); strcat(exec_args[0],"$"); argfound=TRUE; /* start of Arg processing */ while (*tmp != '%' && *tmp != '"' ) { if(*tmp == 's') { strcat(exec_args[0],"*"); break; } if( *tmp > '0' && *tmp <= '9') { strncat(exec_args[0],tmp,1); exec_args[0][strlen(exec_args[0])] = '\0'; } tmp++; } /* end of Arg processing */ /* Get Prompt string if any */ s3 = strchr(argbuf,'"'); if(s3 && *(s3+1) != '"') { s3++; if(!promptfound) { if( (tmp = strchr(s3,'"')) ) { promptfound=TRUE; exec_args[1] = (char *)calloc(1,(tmp-s3)+1); strncpy(exec_args[1],s3,(tmp-s3)); exec_args[1][strlen(exec_args[1])] = '\0'; } } } /* see if there is some stuff between the last '%' and the next first '%' of another Arg */ if( argfound) s2++; argfound = FALSE; s1=s2; } if(argbuf) { free(argbuf); argbuf = NULL; } return exec_args; } /***************************************************************** ** ** ** ProcessContents(FiletypeData *) ** ** ** ** Description: Parses the text string in pszContents field and ** ** fills the sStart,fsFlags and pszContents fields ** ** of the filetypeData datastructure that is passed** ** as input. ** ** ** ** Input : A pointer of type FiletypeData defined in ** ** dtcreate.h ** ** ** ** Output : Fills the sStart, fsFlags and pszContents fields** ** of the FiletypeData pointer and returns 0 (No ** ** error or >0 (error) values. ** ** ** ** Assumptions: Fields are separated by atleast one blank ** ** character. ** ** ** ** references : dtcreate.h, parser.h, and dtcreate spec. ** ** ** ******************************************************************/ int ProcessContents(FiletypeData *pFtD) { char *s1,*tmp,*s2,buf[10],*cts; s1=s2=tmp=cts=NULL; bzero(buf,sizeof(buf)); /* simply return if there is no data in contents field */ if(!pFtD->pszContents) return (0); cts = (char *)calloc(1,strlen(pFtD->pszContents)+1); strcpy(cts,pFtD->pszContents); s1=cts; free(pFtD->pszContents); pFtD->pszContents=NULL; /* Skip all leading spaces */ while( *s1 && isspace(*s1) ) s1++; /* Get the sStart value if any */ /* if( (s1 = strchr(cts,' ')) ) */ while( *s1 && !isspace(*s1) && *s1 != '\n') s1++; if((s1-cts) > 0) { strncpy(buf,cts,(s1-cts)); buf[s1-cts]='\0'; pFtD->sStart=atoi(buf); } while( *s1 && isspace(*s1) ) s1++; /* Get the fsFlags value if any */ tmp=s1; bzero(buf,sizeof(buf)); /* if ( (tmp = strchr(s1,' ')) ) */ while( *tmp && !isspace(*tmp) && *tmp != '\n') tmp++; if((tmp-s1) > 0) { strncpy(buf,s1,(tmp-s1)); buf[tmp-s1]='\0'; if ( !strcmp(buf,"byte") ) pFtD->fsFlags|=CA_FT_CNTBYTE; else if ( !strcmp(buf,"string") ) pFtD->fsFlags|=CA_FT_CNTSTRING; else if ( !strcmp(buf,"long") ) pFtD->fsFlags|=CA_FT_CNTLONG; else if ( !strcmp(buf,"short") ) pFtD->fsFlags|=CA_FT_CNTSHORT; else { free(cts); return (-1); } } while( *tmp && isspace(*tmp) ) tmp++; s2=tmp; /* Get the contents if any */ if (*s2) { pFtD->pszContents = (char *)calloc(1,strlen(s2)+1); strcpy(pFtD->pszContents,s2); free(cts); } return 0; } /***************************************************************** ** ** ** IsLastSingle(char *str) ** ** ** ** Description: returns TRUE if the last character of the ** ** string str is a single-byte character, returns ** ** FALSE if it is a multi-byte character. ** ** ** ******************************************************************/ Boolean IsLastSingle(char *str) { int n = 0; if(MB_CUR_MAX == 1) return(TRUE); while(*str) { n = mblen(str, MB_CUR_MAX); str += n; } if(n > 1) return(FALSE); else return(TRUE); }