smif.c

强大的数学工具包

   /* free memory */    
   Tcl_DStringFree (result); 	    
   if (head != NULL) free (head);
   if (tail != NULL) free (tail);
   if (bodyitem!=NULL) free(bodyitem);
   if (poltemp != NULL) free (poltemp);
   if (polptr != NULL) free (polptr);
   if (result != NULL) free (result);
   if (tempstr != NULL) free (tempstr);
   if (expolist != NULL) free (expolist);
   if (varname != NULL) {
	  for (mm = 0; mm < varcount; mm++)
		 if (varname[mm]!=0) free (varname[mm]);
	  free (varname);
   }
   delchartable (&defaulttable);
   for (polinfoptr = polstruct.polinfo; polinfoptr!= NULL;) {
	  polstruct.polinfo = polinfoptr->next;
	  free (polinfoptr);
	  polinfoptr = polstruct.polinfo;
   }
   return TCL_OK;   
} 


/* Definition des SMif-Befehls : IGNORE   */
int IGNORECmd (ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) 
{
   SMifinfo * smifptr = (SMifinfo*) clientData;
   
   if (argc != 2 && !(argc == 4 && strcmp(argv[1],"NEWLINE")==0 &&
					  strcmp(argv[2],"AFTER") == 0) ) {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong # args:  should be \"IGNORE {...}\" or\n",
						"                       \"IGNORE NEWLINE AFTER {...}\"\n",
						(char*)NULL);
	  return TCL_ERROR;
   }
   if (argc == 2 && ModifySMif_table (argv[1],&(smifptr->envinfo->ignotable),
	   MODIFYTABLE_ADD)==0  ||
	   argc == 4 && ModifySMif_table (argv[3],&(smifptr->envinfo->npnltable),
	   MODIFYTABLE_ADD)==0  ) {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong format: should be { [CHAR] ch1 ch2 ",
						"... [WORD] word1 word2 ... }\n",(char*)NULL);
	  return TCL_ERROR;
   }
   return TCL_OK;
	  	  
}


/* SETITEM : Definition der ITEM SIZE und ITEM PATTERN */
int SETITEMCmd (ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) 
{
   SMifinfo * smifptr = (SMifinfo*) clientData;
   int templen, mm, count;
   
   Tcl_ResetResult (interp);   
   if (argc != 5 || strcmp (argv[1],"SIZE")!=0 || strcmp (argv[3],"PATTERN")!=0) {
	  Tcl_AppendResult (interp, argv[0],": wrong args: should be \"SETITEM SIZE n",
					   " PATTERN patternstr\"\n", (char*) NULL);
	  return TCL_ERROR;
   }
   templen = strlen(argv[2]);
   for (mm = 0; mm < templen; mm++)
	  if (!isdigit(argv[2][mm])) {
		 Tcl_AppendResult (interp, argv[0],": expected positiv integer but got ",
						   "\"",argv[2],"\"\n",(char*)NULL);
		 return TCL_ERROR;
	  }
   count = atoi (argv[2]);
      
   if (!IsValidPattern(argv[4],count,smifptr->interp)) {
	  Tcl_AppendResult (interp, argv[0], ": invalid patternstring \"",argv[4],
						"\"\n", (char*) NULL);
	  return TCL_ERROR;
   }	 
   
   if (smifptr->envinfo->getinfo.type == SMif_GETPOL) {
	  smifptr->envinfo->getinfo.err = ITEMERR;
	  return TCL_ERROR;
   }
   
   smifptr->envinfo->iteminfo.itemsize = count;   
   smifptr->envinfo->iteminfo.pattern = (char*) malloc (sizeof(char)*
										(strlen(argv[4])+2));
   (void)strcpy (smifptr->envinfo->iteminfo.pattern, argv[4]);
   (void)strcpy (smifptr->envinfo->iteminfo.pattern+strlen(argv[4])," ");
   return TCL_OK;
}


int NOPOWERCmd (ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) 
{
   SMifinfo * smifptr = (SMifinfo*) clientData;
   int isok = 1;
  
   /* nopower newline after : fuer die sich fortsetzende Ausgaben. */
   if (argc == 5 && strcmp ("IGNORE",argv[1])==0 && strcmp ("NEWLINE",argv[2])==0
	   && strcmp("AFTER",argv[3])==0 )
	  isok = ModifySMif_table (argv[4], &(smifptr->envinfo->npnltable),
							   MODIFYTABLE_DEL);
   else if (argc == 3 && strcmp("IGNORE",argv[1])==0) 
	  isok = ModifySMif_table (argv[2], &(smifptr->envinfo->ignotable),
							   MODIFYTABLE_DEL);

   else if (argc == 3 && strcmp (argv[1],"STOPGET")==0) 
	  isok = ModifySMif_table (argv[2], &(smifptr->envinfo->stoptable),
							   MODIFYTABLE_DEL); 
   
   else if (argc == 2 && strcmp (argv[1],"SETITEM")==0) {
	  smifptr->envinfo->iteminfo.itemsize = 1;
	  if (smifptr->envinfo->iteminfo.pattern!=NULL) {
		 free (smifptr->envinfo->iteminfo.pattern);
		 smifptr->envinfo->iteminfo.pattern = NULL;
	  }
   }
   else {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong args: should be \"NOPOWER IGNORE",
						" {...}\" or ","\"NOPOWER STOPGET {...}\" or\n",
						"\"NOPOWER SETITEM\" or ", 
						"\"NOPOWER IGNORE NEWLINE AFTER {...}\"\n", (char*)NULL);
	  return TCL_ERROR;
   }
   if (!isok) {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong format: should be { [CHAR} ch1 ch2 ",
						"... [WORD] word1 word2 ...}", (char*)NULL );
	  return TCL_ERROR;
   }
   return TCL_OK;
}


/* stopget: wann soll ein GET beendet werden ?  default: eof OR foreach... */

int STOPGETCmd (ClientData clientData, Tcl_Interp *interp, int argc, char *argv[]) 
{
   SMifinfo * smifptr = (SMifinfo*) clientData;
      
   if (argc != 4 || strcmp ("IF",argv[1])!=0 || strcmp("SEE",argv[2])!=0) {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong args: should be \"STOPGET IF",
						" SEE {...}\"\n", (char*)NULL);
	  return TCL_ERROR;
   }
   if (ModifySMif_table (argv[3],&(smifptr->envinfo->stoptable),MODIFYTABLE_ADD)==0) {
	  Tcl_ResetResult (interp);
	  Tcl_AppendResult (interp, argv[0],": wrong format: should be { [CHAR] ch1 ch2 ",
						"... [WORD] word1 word2 ...}", (char*)NULL);
	  return TCL_ERROR;
   }
   return TCL_OK; 	     
}

void DeleteAll (SMifinfo *SMifptr)
{
   int mm;
   struct EnvInfoItem *envinfoptr,*envinfoptr2;
   for (mm = 0; mm < SMifptr->fbuffer.linecount; mm++) 
	  free (SMifptr->fbuffer.lines[mm].line);
   free (SMifptr->fbuffer.lines);
   for (envinfoptr = SMifptr->envinfo; envinfoptr!=NULL;) {
	  delchartable (&(envinfoptr->ignotable.chartable));
	  delchartable (&(envinfoptr->npnltable.chartable));
	  delchartable (&(envinfoptr->stoptable.chartable));
	  delchartable (&(envinfoptr->repeattable.chartable));
	  delwordtable (&(envinfoptr->ignotable.wordtable));
	  delwordtable (&(envinfoptr->stoptable.wordtable));
	  delwordtable (&(envinfoptr->npnltable.wordtable));
	  delwordtable (&(envinfoptr->repeattable.wordtable));
	  free (envinfoptr->iteminfo.pattern);
	  envinfoptr2 = envinfoptr;
	  envinfoptr = envinfoptr2->next;
	  free (envinfoptr2);
   }
   Tcl_DStringFree (&(SMifptr->result));
   free (SMifptr);
}


/* Initialisierung einer neuen GET_Umgebung ueber einer alten
   Umgebung (NULL, falls nicht vorhanden */
   
void InitEnvinfo (EnvInfo newenv, EnvInfo oldenv)
{  
   if (oldenv == NULL) {      /* level 0 */
	  newenv->envlevel = 0;
	  newenv->next = NULL;
	  newenv->ignotable.chartable = NULL;
	  newenv->ignotable.wordtable = NULL;
	  newenv->stoptable.chartable = NULL;
	  newenv->stoptable.wordtable = NULL;
	  newenv->npnltable.chartable = NULL;
	  newenv->npnltable.wordtable = NULL;
	  newenv->repeattable.chartable = NULL;
	  newenv->repeattable.wordtable = NULL;
	  newenv->iteminfo.itemsize = 1;
	  newenv->iteminfo.pattern  = NULL;
	  addchar ('\n',&(newenv->ignotable.chartable));
	  addchar ('\t',&(newenv->ignotable.chartable));
	  addchar (' ',&(newenv->ignotable.chartable));
   }
   else {                    /* level > 0 */ 
	  newenv->envlevel = oldenv->envlevel + 1;
	  newenv->next = oldenv;
	  newenv->ignotable.chartable = copychartable (oldenv->ignotable.chartable);
	  newenv->ignotable.wordtable = copywordtable (oldenv->ignotable.wordtable);
	  newenv->stoptable.chartable = copychartable (oldenv->stoptable.chartable);
	  newenv->stoptable.wordtable = copywordtable (oldenv->stoptable.wordtable);	  
	  newenv->npnltable.chartable = copychartable (oldenv->npnltable.chartable);
	  newenv->npnltable.wordtable = copywordtable (oldenv->npnltable.wordtable);
	  newenv->repeattable.chartable = copychartable (oldenv->repeattable.chartable);
	  newenv->repeattable.wordtable = copywordtable (oldenv->repeattable.wordtable);	  
	  newenv->iteminfo.itemsize = oldenv->iteminfo.itemsize;
	  if (oldenv->iteminfo.pattern != NULL) {
		 newenv->iteminfo.pattern = (char*) malloc (sizeof(char) * (strlen (
						 oldenv->iteminfo.pattern)+1));
		 (void)strcpy (newenv->iteminfo.pattern, oldenv->iteminfo.pattern);
	  } 
	  else newenv->iteminfo.pattern = NULL;
   }
   newenv->getinfo.type       = UNDEFINED;
   newenv->getinfo.subtype    = UNDEFINED;
   newenv->getinfo.err        = NOERROR;
   newenv->getinfo.count      = 0;
   newenv->getinfo.getcount   = 0;
}


/* Aenderung der SMif-tabelle */
int ModifySMif_table (char* instr, SMif_table * table, int flag)
{
   char * tempstr; 
   int count, wordcount, length;
   SMif_chartable ignotable = NULL;
   int ischar = 0, isword = 0;  /* bool */
   
   addchar ('\n',&ignotable);
   addchar ('\t',&ignotable);
   addchar (' ',&ignotable);
   count = 1;
   wordcount = SMif_wordcount (instr,ignotable);
   while (count <= wordcount) {
	  tempstr = SMif_getword (instr, count, ignotable);
	  if (strcmp (tempstr,"[CHAR]")== 0) {
		 isword = 0; 
		 ischar = 1;
	  } 
	  else if (strcmp (tempstr, "[WORD]")==0) {
		 isword = 1;
		 ischar = 0;
	  }
	  else {
		 length = strlen (tempstr);
		 if (count == 1) { free (tempstr); return 0; }
		 if (ischar) {
			if (length != 1) {
			   if (length == 2 && tempstr[0] == '\\')
				  switch (flag) {
					 case MODIFYTABLE_ADD: addchar (tempstr[1],&(table->chartable));
										   break;
					 case MODIFYTABLE_DEL: delchar (tempstr[1],&(table->chartable));
				  }
			   else {
				  free (tempstr);
				  return 0;
			   }
			} 
			else 
			   switch (flag) {
				  case MODIFYTABLE_ADD: addchar(tempstr[0],&(table->chartable));
										break;
				  case MODIFYTABLE_DEL: delchar(tempstr[0],&(table->chartable));
			   }
		 }
		 if (isword) 
			switch (flag) {
			   case MODIFYTABLE_ADD: addword (tempstr,&(table->wordtable));
									 break;
			   case MODIFYTABLE_DEL: delword (tempstr,&(table->wordtable));
			}
	  }
	  free (tempstr);
	  count ++;
   }
   return 1;
}			   
	   
	   
/* check: ist der String eine gueltige Patternbeschreibung ? */
int IsValidPattern (const char* str, int count, Tcl_Interp* interp) 
{
   int occour = SMif_occour (str,"$");
   char nummer[10], *tempstr = NULL;
   int mm, nn, tempint, pos;
   
   for (mm = 1; mm <= occour; mm++) {
	  pos = SMif_at (str, "$", mm);
	  for (nn = 0; isdigit(str[pos+nn+1]);nn++)
		 nummer[nn] = str[pos+nn+1];
	  nummer[nn] = '\0';
	  tempint = atoi (nummer);
	  if (tempint < 1 || tempint > count) 
		 return 0;
   }
   
   /* setze $1 durch 1, $2 durch 2 ... und berechnen: Syntax OK? */
   tempstr = SMif_strtran (str, "$","");
   if (Tcl_ExprString(interp,tempstr)==TCL_ERROR) {
      Tcl_ResetResult (interp);
	  free (tempstr);
	  Tcl_AppendResult (interp, "\n",(char*)NULL);
	  return 0;
   }
   Tcl_ResetResult (interp);
   free (tempstr);
   return 1;  
}


/* check: ist das aktuelle Wort bzw. sind die Zeichen des Wortes in der Tabelle?*/
int IsObjInTab (char* tempword, int * curposptr, SMif_table * tableptr, int seen) 
{
   int templen, mm;
			   
   if (tempword == NULL) return 0;
   templen = strlen(tempword);
   if (seen) {
	  for (mm=0; mm < templen; mm++) 
		 if ( isinchartable (tempword[mm],tableptr->chartable)) {
			(*curposptr) += (mm+1);
			return 1;
		 }
	  if (isinwordtable (tempword, tableptr->wordtable)) {
		 (*curposptr) += templen;	
		 return 1;
	  }
   } else {
	  if (isinwordtable (tempword, tableptr->wordtable))
		 return 1;
	  for (mm=0; mm < templen; mm++)
		 if (isinchartable (tempword[mm],tableptr->chartable)) {
			(*curposptr) += mm;
			return 1;
		 }
   }
   return 0;
}	
	  
	  
/* IsNPNLString */
int IsNPNLString (char* string, SMif_table * npnltabptr) 
{
   int length, occours;
   struct SMif_charlistitem * charitemptr;
   struct SMif_wordlistitem * worditemptr;
   
   if (string == NULL || npnltabptr->chartable == NULL && 
	   npnltabptr->wordtable == NULL) return 0;
   length = strlen(string);
   for (charitemptr = npnltabptr->chartable; charitemptr!=NULL; 
		charitemptr = charitemptr->next)
	  if (string[length-1] == charitemptr->SMifchar) {
		 string[length-1] = '\0';
		 return 1;
	  }
   for (worditemptr = npnltabptr->wordtable; worditemptr!=NULL;
		worditemptr = worditemptr->next)
	  if ( (occours = SMif_occour(string, worditemptr->SMifword)) > 0 &&
		   SMif_at (string, worditemptr->SMifword, occours) + 
		   strlen(worditemptr->SMifword)  == length) {
		 string[SMif_at(string,worditemptr->SMifword,occours)] = '\0';
		 return 1;
	  }
   return 0;
}  


/* Get next word from current position */
char * GetNextWord (FileBuffer* fbptr, SMif_table* ignotabptr, int *lgetcount)
{
   LineBuffer* lbptr = &(fbptr->lines[fbptr->curline]);
   char * curword = NULL;
   
   if (fbptr->eof) return NULL;
   curword = SMif_getword (lbptr->line+lbptr->curpos,1,
			  ignotabptr->chartable);
   lbptr->curpos += SMif_lwastecount (lbptr->line+lbptr->curpos,
			  ignotabptr->chartable);		   
   while ( curword == NULL && !fbptr->eof || 
		   isinwordtable(curword,ignotabptr->wordtable))
   {
	  if (curword == NULL) {
		 fbptr->curline ++;
		 if (fbptr->curline >= fbptr->linecount) {
			fbptr->curline = fbptr->linecount-1;
			fbptr->eof = 1;