[p5sagit/p5-mst-13.2.git] / vms / munchconfig.c

/* munchconfig.c

   A very, very (very!) simple program to process a config_h.sh file on
   non-unix systems.

   usage:
   munchconfig config.sh config_h.sh [foo=bar [baz=xyzzy [...]]] >config.h

   which is to say, it takes as its firt parameter a config.sh (or
   equivalent), as its second a config_h.sh (or equvalent), and a list of
   optional tag=value pairs.

   It spits the processed config.h out to STDOUT.

   */

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/* The failure code to exit with */
#ifndef EXIT_FAILURE
#ifdef VMS
#define EXIT_FAILURE 0
#else
#define EXIT_FAILURE -1
#endif
#endif

/* The biggest line we can read in from a file */
#define LINEBUFFERSIZE 400
#define NUMTILDESUBS 30
#define NUMCONFIGSUBS 1000
#define TOKENBUFFERSIZE 80

typedef struct {
  char Tag[TOKENBUFFERSIZE];
  char Value[512];
} Translate;

void tilde_sub(char [], Translate [], int);

int
main(int argc, char *argv[])
{
  FILE *ConfigSH, *Config_H;
  char LineBuffer[LINEBUFFERSIZE], *TempValue, *StartTilde, *EndTilde;
  char SecondaryLineBuffer[LINEBUFFERSIZE];
  char TokenBuffer[TOKENBUFFERSIZE];
  int LineBufferLength, TempLength, DummyVariable, LineBufferLoop;
  int TokenBufferLoop, ConfigSubLoop, GotIt;
  Translate TildeSub[NUMTILDESUBS];    /* Holds the tilde (~FOO~) */
                                       /* substitutions */
  Translate ConfigSub[NUMCONFIGSUBS];  /* Holds the substitutions from */
                                       /* config.sh */
  int TildeSubCount = 0, ConfigSubCount = 0; /* # of tilde substitutions */
                                             /* and config substitutions, */
                                             /* respectively */
  if (argc < 3) {
    printf("Usage: munchconfig config.sh config_h.sh [foo=bar [baz=xyzzy [...]]]\n");
    exit(EXIT_FAILURE);
  }

  
  /* First, open the input files */
  if (NULL == (ConfigSH = fopen(argv[1], "r"))) {
    printf("Error %i trying to open config.sh file %s\n", errno, argv[1]);
    exit(EXIT_FAILURE);
  }
  
  if (NULL == (Config_H = fopen(argv[2], "r"))) {
    printf("Error %i trying to open config_h.sh file %s\n", errno, argv[2]);
    exit(EXIT_FAILURE);
  }

  /* Any tag/value pairs on the command line? */
  if (argc > 3) {
    int i;
    char WorkString[80]; 
    for (i=3; i < argc && argv[i]; i++) {
      
      /* Local copy */
      strcpy(WorkString, argv[i]);
      /* Stick a NULL over the = */
      TempValue = strchr(WorkString, '=');
      *TempValue++ = '\0';

      /* Copy the tag and value into the holding array */
      strcpy(TildeSub[TildeSubCount].Tag, WorkString);
      strcpy(TildeSub[TildeSubCount].Value, TempValue);
      TildeSubCount++;
    }
  }

  /* Now read in the config.sh file. */
  while(fgets(LineBuffer, LINEBUFFERSIZE - 1, ConfigSH)) {
    /* Force a trailing null, just in case */
    LineBuffer[LINEBUFFERSIZE - 1] = '\0';

    LineBufferLength = strlen(LineBuffer);

    /* Chop trailing control characters */
    while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
      LineBuffer[LineBufferLength - 1] = '\0';
      LineBufferLength--;
    }

    /* If it's empty, then try again */
    if (!*LineBuffer)
      continue;

    /* If the line begins with a '#' or ' ', skip */
    if ((LineBuffer[0] == ' ') || (LineBuffer[0] == '#'))
      continue;

    /* We've got something. Guess we need to actually handle it */
    /* Do the tilde substitution */
    tilde_sub(LineBuffer, TildeSub, TildeSubCount);

    /* Stick a NULL over the = */
    TempValue = strchr(LineBuffer, '=');
    *TempValue++ = '\0';
    /* And another over the leading ', which better be there */
    *TempValue++ = '\0';
    
    /* Check to see if there's a trailing ' or ". If not, add a newline to
       the buffer and grab another line. */
    TempLength = strlen(TempValue);
    while ((TempValue[TempLength-1] != '\'') &&
           (TempValue[TempLength-1] != '"'))  {
      fgets(SecondaryLineBuffer, LINEBUFFERSIZE - 1, ConfigSH);
      /* Force a trailing null, just in case */
      SecondaryLineBuffer[LINEBUFFERSIZE - 1] = '\0';
      /* Go substitute */
      tilde_sub(SecondaryLineBuffer, TildeSub, TildeSubCount);
      /* Tack a nweline on the end of our primary buffer */
      strcat(TempValue, "\n");
      /* Concat the new line we just read */
      strcat(TempValue, SecondaryLineBuffer);

      /* Refigure the length */
      TempLength = strlen(TempValue);
      
      /* Chop trailing control characters */
      while((TempLength > 0) && (TempValue[TempLength-1] < ' ')) {
        TempValue[TempLength - 1] = '\0';
        TempLength--;
      }
    }
    
    /* And finally one over the trailing ' */
    TempValue[TempLength-1] = '\0';

    /* Is there even anything left? */
    if(*TempValue) {
      /* Copy the tag over */
      strcpy(ConfigSub[ConfigSubCount].Tag, LineBuffer);
      /* Copy the value over */
      strcpy(ConfigSub[ConfigSubCount].Value, TempValue);

      /* Up the count */
      ConfigSubCount++;

    }
  }

  /* Okay, we've read in all the substititions from our config.sh */
  /* equivalent. Read in the config_h.sh equiv and start the substitution */
  
  /* First, eat all the lines until we get to one with !GROK!THIS! in it */
  while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
                "!GROK!THIS!")) {

    /* Dummy statement to shut up any compiler that'll whine about an empty */
    /* loop */
    DummyVariable++;
  }

  /* Right, we've read all the lines through the first one with !GROK!THIS! */
  /* in it. That gets us through the beginning stuff. Now start in earnest */
  /* with our translations, which run until we get to another !GROK!THIS! */
  while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
                "!GROK!THIS!")) {
    /* Force a trailing null, just in case */
    LineBuffer[LINEBUFFERSIZE - 1] = '\0';
    
    /* Tilde Substitute */
    tilde_sub(LineBuffer, TildeSub, TildeSubCount);

    LineBufferLength = strlen(LineBuffer);
    
    /* Chop trailing control characters */
    while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
      LineBuffer[LineBufferLength - 1] = '\0';
      LineBufferLength--;
    }

    /* Right. Go looking for $s. */
    for(LineBufferLoop = 0; LineBufferLoop < LineBufferLength;
        LineBufferLoop++) {
      /* Did we find one? */
      if ('$' != LineBuffer[LineBufferLoop]) {
        /* Nope, spit out the value */
        putchar(LineBuffer[LineBufferLoop]);
      } else {
        /* Yes, we did. Is it escaped? */
        if ((LineBufferLoop > 0) && ('\\' == LineBuffer[LineBufferLoop -
                                                       1])) {
          /* Yup. Spit it out */
          putchar(LineBuffer[LineBufferLoop]);
        } else {
         /* Nope. Go grab us a token */
          TokenBufferLoop = 0;
          /* Advance to the next character in the input stream */
          LineBufferLoop++;
          while((LineBufferLoop < LineBufferLength) &&
                ((isalnum(LineBuffer[LineBufferLoop]) || ('_' ==
                                                          LineBuffer[LineBufferLoop])))) {
            TokenBuffer[TokenBufferLoop] = LineBuffer[LineBufferLoop];
            LineBufferLoop++;
            TokenBufferLoop++;
          }

          /* Trailing null on the token buffer */
          TokenBuffer[TokenBufferLoop] = '\0';

          /* Back the line buffer pointer up one */
          LineBufferLoop--;
          
          /* Right, we're done grabbing a token. Check to make sure we got */
          /* something */
          if (TokenBufferLoop) {
            /* Well, we do. Run through all the tokens we've got in the */
            /* ConfigSub array and see if any match */
            GotIt = 0;
            for(ConfigSubLoop = 0; ConfigSubLoop < ConfigSubCount;
                ConfigSubLoop++) {
              if (!strcmp(TokenBuffer, ConfigSub[ConfigSubLoop].Tag)) {
                GotIt = 1;
                printf("%s", ConfigSub[ConfigSubLoop].Value);
                break;
              }
            }

            /* Did we find something? If not, spit out what was in our */
            /* buffer */
            if (!GotIt) {
              printf("$%s", TokenBuffer);
            }
            
          } else {
            /* Just a bare $. Spit it out */
            putchar('$');
          }       
        }
      }
    }
    
    /* We're all done. Spit out an EOL */
    printf("\n");
    
    
  }
  
  /* Close the files */
  fclose(ConfigSH);
  fclose(Config_H);
}

void
tilde_sub(char LineBuffer[], Translate TildeSub[], int TildeSubCount)
{
  char TempBuffer[LINEBUFFERSIZE], TempTilde[TOKENBUFFERSIZE];
  int TildeLoop, InTilde, CopiedBufferLength, TildeBufferLength, k, GotIt;
  int TempLength;
  InTilde = 0;
  CopiedBufferLength = 0;
  TildeBufferLength = 0;
  TempLength = strlen(LineBuffer);

  /* Grovel over our input looking for ~foo~ constructs */
  for(TildeLoop = 0; TildeLoop < TempLength; TildeLoop++) {
    /* Are we in a tilde? */
    if (InTilde) {
      /* Yup. Is the current character a tilde? */
      if (LineBuffer[TildeLoop] == '~') {
        /* Yup. That means we're ready to do a substitution */
        InTilde = 0;
        GotIt = 0;
        /* Trailing null */
        TempTilde[TildeBufferLength] = '\0';
        for( k=0; k < TildeSubCount; k++) {
          if (!strcmp(TildeSub[k].Tag, TempTilde)) {
            GotIt = 1;
            /* Tack on the trailing null to the main buffer */
            TempBuffer[CopiedBufferLength] = '\0';
            /* Copy the tilde substitution over */
            strcat(TempBuffer, TildeSub[k].Value);
            CopiedBufferLength = strlen(TempBuffer);
          }
        }
        
        /* Did we find anything? */
        if (GotIt == 0) {
          /* Guess not. Copy the whole thing out verbatim */
          TempBuffer[CopiedBufferLength] = '\0';
          TempBuffer[CopiedBufferLength++] = '~';
          TempBuffer[CopiedBufferLength] = '\0';
          strcat(TempBuffer, TempTilde);
          strcat(TempBuffer, "~");
          CopiedBufferLength = strlen(TempBuffer);
        }
        
      } else {
        /* 'Kay, not a tilde. Is it a word character? */
        if (isalnum(LineBuffer[TildeLoop]) || (LineBuffer[TildeLoop] =
                                              '-') ||
            (LineBuffer[TildeLoop] == '-')) {
          TempTilde[TildeBufferLength++] = LineBuffer[TildeLoop];
        } else {
          /* No, it's not a tilde character. For shame! We've got a */
          /* bogus token. Copy a ~ into the output buffer, then append */
          /* whatever we've got in our token buffer */
          TempBuffer[CopiedBufferLength++] = '~';
          TempBuffer[CopiedBufferLength] = '\0';
          TempTilde[TildeBufferLength] = '\0';
          strcat(TempBuffer, TempTilde);
          CopiedBufferLength += TildeBufferLength;
          InTilde = 0;
        }
      }
    } else {
      /* We're not in a tilde. Do we want to be? */
      if (LineBuffer[TildeLoop] == '~') {
        /* Guess so */
        InTilde = 1;
        TildeBufferLength = 0;
      } else {
        /* Nope. Copy the character to the output buffer */
        TempBuffer[CopiedBufferLength++] = LineBuffer[TildeLoop];
      }
    }
  }
  
  /* Out of the loop. First, double-check to see if there was anything */
  /* pending. */
  if (InTilde) {
    /* bogus token. Copy a ~ into the output buffer, then append */
    /* whatever we've got in our token buffer */
    TempBuffer[CopiedBufferLength++] = '~';
    TempBuffer[CopiedBufferLength] = '\0';
    TempTilde[TildeBufferLength] = '\0';
    strcat(TempBuffer, TempTilde);
    CopiedBufferLength += TildeBufferLength;
  } else {
    /* Nope, nothing pensing. Tack on a \0 */
    TempBuffer[CopiedBufferLength] = '\0';
  }

  /* Okay, we're done. Copy the temp buffer back into the line buffer */
  strcpy(LineBuffer, TempBuffer);

}
Commit	Line	Data
97abc6ad	1	/* munchconfig.c
	2
	3	A very, very (very!) simple program to process a config_h.sh file on
	4	non-unix systems.
	5
	6	usage:
	7	munchconfig config.sh config_h.sh [foo=bar [baz=xyzzy [...]]] >config.h
	8
	9	which is to say, it takes as its firt parameter a config.sh (or
	10	equivalent), as its second a config_h.sh (or equvalent), and a list of
	11	optional tag=value pairs.
	12
	13	It spits the processed config.h out to STDOUT.
	14
	15	*/
	16
	17	#include <stdio.h>
	18	#include <errno.h>
	19	#include <stdlib.h>
	20	#include <string.h>
	21	#include <ctype.h>
	22
	23	/* The failure code to exit with */
	24	#ifndef EXIT_FAILURE
	25	#ifdef VMS
	26	#define EXIT_FAILURE 0
	27	#else
	28	#define EXIT_FAILURE -1
	29	#endif
	30	#endif
	31
	32	/* The biggest line we can read in from a file */
	33	#define LINEBUFFERSIZE 400
	34	#define NUMTILDESUBS 30
	35	#define NUMCONFIGSUBS 1000
	36	#define TOKENBUFFERSIZE 80
	37
	38	typedef struct {
	39	char Tag[TOKENBUFFERSIZE];
	40	char Value[512];
	41	} Translate;
	42
	43	void tilde_sub(char [], Translate [], int);
	44
	45	int
	46	main(int argc, char *argv[])
	47	{
	48	FILE ConfigSH, Config_H;
	49	char LineBuffer[LINEBUFFERSIZE], TempValue, StartTilde, *EndTilde;
	50	char SecondaryLineBuffer[LINEBUFFERSIZE];
	51	char TokenBuffer[TOKENBUFFERSIZE];
	52	int LineBufferLength, TempLength, DummyVariable, LineBufferLoop;
	53	int TokenBufferLoop, ConfigSubLoop, GotIt;
	54	Translate TildeSub[NUMTILDESUBS]; /* Holds the tilde (~FOO~) */
	55	/* substitutions */
	56	Translate ConfigSub[NUMCONFIGSUBS]; /* Holds the substitutions from */
	57	/* config.sh */
	58	int TildeSubCount = 0, ConfigSubCount = 0; /* # of tilde substitutions */
	59	/* and config substitutions, */
	60	/* respectively */
	61	if (argc < 3) {
	62	printf("Usage: munchconfig config.sh config_h.sh [foo=bar [baz=xyzzy [...]]]\n");
	63	exit(EXIT_FAILURE);
	64	}
65
66
67	/* First, open the input files */
68	if (NULL == (ConfigSH = fopen(argv[1], "r"))) {
69	printf("Error %i trying to open config.sh file %s\n", errno, argv[1]);
70	exit(EXIT_FAILURE);
71	}
72
73	if (NULL == (Config_H = fopen(argv[2], "r"))) {
74	printf("Error %i trying to open config_h.sh file %s\n", errno, argv[2]);
75	exit(EXIT_FAILURE);
76	}
77
78	/* Any tag/value pairs on the command line? */
79	if (argc > 3) {
80	int i;
81	char WorkString[80];
82	for (i=3; i < argc && argv[i]; i++) {
83
84	/* Local copy */
85	strcpy(WorkString, argv[i]);
86	/* Stick a NULL over the = */
87	TempValue = strchr(WorkString, '=');
88	*TempValue++ = '\0';
89
90	/* Copy the tag and value into the holding array */
91	strcpy(TildeSub[TildeSubCount].Tag, WorkString);
92	strcpy(TildeSub[TildeSubCount].Value, TempValue);
93	TildeSubCount++;
94	}
95	}
96
97	/* Now read in the config.sh file. */
98	while(fgets(LineBuffer, LINEBUFFERSIZE - 1, ConfigSH)) {
99	/* Force a trailing null, just in case */
100	LineBuffer[LINEBUFFERSIZE - 1] = '\0';
101
102	LineBufferLength = strlen(LineBuffer);
103
104	/* Chop trailing control characters */
105	while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
106	LineBuffer[LineBufferLength - 1] = '\0';
107	LineBufferLength--;
108	}
109
110	/* If it's empty, then try again */
111	if (!*LineBuffer)
112	continue;
113
114	/* If the line begins with a '#' or ' ', skip */
115	if ((LineBuffer[0] == ' ') \|\| (LineBuffer[0] == '#'))
116	continue;
117
118	/* We've got something. Guess we need to actually handle it */
119	/* Do the tilde substitution */
120	tilde_sub(LineBuffer, TildeSub, TildeSubCount);
121
122	/* Stick a NULL over the = */
123	TempValue = strchr(LineBuffer, '=');
124	*TempValue++ = '\0';
125	/* And another over the leading ', which better be there */
126	*TempValue++ = '\0';
127
b6e4eeb2	128	/* Check to see if there's a trailing ' or ". If not, add a newline to
b6e4eeb2	129	the buffer and grab another line. */
97abc6ad	130	TempLength = strlen(TempValue);
b6e4eeb2	131	while ((TempValue[TempLength-1] != '\'') &&
b6e4eeb2	132	(TempValue[TempLength-1] != '"')) {
97abc6ad	133	fgets(SecondaryLineBuffer, LINEBUFFERSIZE - 1, ConfigSH);
	134	/* Force a trailing null, just in case */
	135	SecondaryLineBuffer[LINEBUFFERSIZE - 1] = '\0';
	136	/* Go substitute */
	137	tilde_sub(SecondaryLineBuffer, TildeSub, TildeSubCount);
	138	/* Tack a nweline on the end of our primary buffer */
	139	strcat(TempValue, "\n");
	140	/* Concat the new line we just read */
	141	strcat(TempValue, SecondaryLineBuffer);
	142
	143	/* Refigure the length */
	144	TempLength = strlen(TempValue);
	145
	146	/* Chop trailing control characters */
	147	while((TempLength > 0) && (TempValue[TempLength-1] < ' ')) {
	148	TempValue[TempLength - 1] = '\0';
	149	TempLength--;
	150	}
	151	}
	152
	153	/* And finally one over the trailing ' */
	154	TempValue[TempLength-1] = '\0';
	155
	156	/* Is there even anything left? */
	157	if(*TempValue) {
	158	/* Copy the tag over */
	159	strcpy(ConfigSub[ConfigSubCount].Tag, LineBuffer);
	160	/* Copy the value over */
	161	strcpy(ConfigSub[ConfigSubCount].Value, TempValue);
	162
	163	/* Up the count */
	164	ConfigSubCount++;
	165
	166	}
	167	}
	168
	169	/* Okay, we've read in all the substititions from our config.sh */
	170	/* equivalent. Read in the config_h.sh equiv and start the substitution */
	171
	172	/* First, eat all the lines until we get to one with !GROK!THIS! in it */
	173	while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
	174	"!GROK!THIS!")) {
	175
	176	/* Dummy statement to shut up any compiler that'll whine about an empty */
	177	/* loop */
	178	DummyVariable++;
	179	}
	180
	181	/* Right, we've read all the lines through the first one with !GROK!THIS! */
	182	/* in it. That gets us through the beginning stuff. Now start in earnest */
	183	/* with our translations, which run until we get to another !GROK!THIS! */
	184	while(!strstr(fgets(LineBuffer, LINEBUFFERSIZE, Config_H),
	185	"!GROK!THIS!")) {
	186	/* Force a trailing null, just in case */
	187	LineBuffer[LINEBUFFERSIZE - 1] = '\0';
	188
	189	/* Tilde Substitute */
	190	tilde_sub(LineBuffer, TildeSub, TildeSubCount);
	191
	192	LineBufferLength = strlen(LineBuffer);
	193
	194	/* Chop trailing control characters */
	195	while((LineBufferLength > 0) && (LineBuffer[LineBufferLength-1] < ' ')) {
	196	LineBuffer[LineBufferLength - 1] = '\0';
197	LineBufferLength--;
198	}
199
200	/* Right. Go looking for $s. */
201	for(LineBufferLoop = 0; LineBufferLoop < LineBufferLength;
202	LineBufferLoop++) {
203	/* Did we find one? */
204	if ('$' != LineBuffer[LineBufferLoop]) {
205	/* Nope, spit out the value */
206	putchar(LineBuffer[LineBufferLoop]);
207	} else {
208	/* Yes, we did. Is it escaped? */
209	if ((LineBufferLoop > 0) && ('\\' == LineBuffer[LineBufferLoop -
210	1])) {
211	/* Yup. Spit it out */
212	putchar(LineBuffer[LineBufferLoop]);
213	} else {
214	/* Nope. Go grab us a token */
215	TokenBufferLoop = 0;
216	/* Advance to the next character in the input stream */
217	LineBufferLoop++;
218	while((LineBufferLoop < LineBufferLength) &&
219	((isalnum(LineBuffer[LineBufferLoop]) \|\| ('_' ==
220	LineBuffer[LineBufferLoop])))) {
221	TokenBuffer[TokenBufferLoop] = LineBuffer[LineBufferLoop];
222	LineBufferLoop++;
223	TokenBufferLoop++;
224	}
225
226	/* Trailing null on the token buffer */
227	TokenBuffer[TokenBufferLoop] = '\0';
228
229	/* Back the line buffer pointer up one */
230	LineBufferLoop--;
231
232	/* Right, we're done grabbing a token. Check to make sure we got */
233	/* something */
234	if (TokenBufferLoop) {
235	/* Well, we do. Run through all the tokens we've got in the */
236	/* ConfigSub array and see if any match */
237	GotIt = 0;
238	for(ConfigSubLoop = 0; ConfigSubLoop < ConfigSubCount;
239	ConfigSubLoop++) {
240	if (!strcmp(TokenBuffer, ConfigSub[ConfigSubLoop].Tag)) {
241	GotIt = 1;
242	printf("%s", ConfigSub[ConfigSubLoop].Value);
243	break;
244	}
245	}
246
247	/* Did we find something? If not, spit out what was in our */
248	/* buffer */
249	if (!GotIt) {
250	printf("$%s", TokenBuffer);
251	}
252
253	} else {
254	/* Just a bare $. Spit it out */
255	putchar('$');
256	}
257	}
258	}
259	}
260
261	/* We're all done. Spit out an EOL */
262	printf("\n");
263
264
265	}
266
267	/* Close the files */
268	fclose(ConfigSH);
269	fclose(Config_H);
270	}
271
272	void
273	tilde_sub(char LineBuffer[], Translate TildeSub[], int TildeSubCount)
274	{
275	char TempBuffer[LINEBUFFERSIZE], TempTilde[TOKENBUFFERSIZE];
276	int TildeLoop, InTilde, CopiedBufferLength, TildeBufferLength, k, GotIt;
277	int TempLength;
278	InTilde = 0;
279	CopiedBufferLength = 0;
280	TildeBufferLength = 0;
281	TempLength = strlen(LineBuffer);
282
283	/* Grovel over our input looking for ~foo~ constructs */
284	for(TildeLoop = 0; TildeLoop < TempLength; TildeLoop++) {
285	/* Are we in a tilde? */
286	if (InTilde) {
287	/* Yup. Is the current character a tilde? */
288	if (LineBuffer[TildeLoop] == '~') {
289	/* Yup. That means we're ready to do a substitution */
290	InTilde = 0;
291	GotIt = 0;
292	/* Trailing null */
293	TempTilde[TildeBufferLength] = '\0';
294	for( k=0; k < TildeSubCount; k++) {
295	if (!strcmp(TildeSub[k].Tag, TempTilde)) {
296	GotIt = 1;
297	/* Tack on the trailing null to the main buffer */
298	TempBuffer[CopiedBufferLength] = '\0';
299	/* Copy the tilde substitution over */
300	strcat(TempBuffer, TildeSub[k].Value);
301	CopiedBufferLength = strlen(TempBuffer);
302	}
303	}
304
305	/* Did we find anything? */
306	if (GotIt == 0) {
307	/* Guess not. Copy the whole thing out verbatim */
308	TempBuffer[CopiedBufferLength] = '\0';
309	TempBuffer[CopiedBufferLength++] = '~';
310	TempBuffer[CopiedBufferLength] = '\0';
311	strcat(TempBuffer, TempTilde);
312	strcat(TempBuffer, "~");
313	CopiedBufferLength = strlen(TempBuffer);
314	}
315
316	} else {
317	/* 'Kay, not a tilde. Is it a word character? */
318	if (isalnum(LineBuffer[TildeLoop]) \|\| (LineBuffer[TildeLoop] =
319	'-') \|\|
320	(LineBuffer[TildeLoop] == '-')) {
321	TempTilde[TildeBufferLength++] = LineBuffer[TildeLoop];
322	} else {
323	/* No, it's not a tilde character. For shame! We've got a */
324	/* bogus token. Copy a ~ into the output buffer, then append */
325	/* whatever we've got in our token buffer */
326	TempBuffer[CopiedBufferLength++] = '~';
327	TempBuffer[CopiedBufferLength] = '\0';
328	TempTilde[TildeBufferLength] = '\0';
329	strcat(TempBuffer, TempTilde);
330	CopiedBufferLength += TildeBufferLength;
331	InTilde = 0;
332	}
333	}
334	} else {
335	/* We're not in a tilde. Do we want to be? */
336	if (LineBuffer[TildeLoop] == '~') {
337	/* Guess so */
338	InTilde = 1;
339	TildeBufferLength = 0;
340	} else {
341	/* Nope. Copy the character to the output buffer */
342	TempBuffer[CopiedBufferLength++] = LineBuffer[TildeLoop];
343	}
344	}
345	}
346
347	/* Out of the loop. First, double-check to see if there was anything */
348	/* pending. */
349	if (InTilde) {
350	/* bogus token. Copy a ~ into the output buffer, then append */
351	/* whatever we've got in our token buffer */
352	TempBuffer[CopiedBufferLength++] = '~';
353	TempBuffer[CopiedBufferLength] = '\0';
354	TempTilde[TildeBufferLength] = '\0';
355	strcat(TempBuffer, TempTilde);
356	CopiedBufferLength += TildeBufferLength;
357	} else {
358	/* Nope, nothing pensing. Tack on a \0 */
359	TempBuffer[CopiedBufferLength] = '\0';
360	}
361
362	/* Okay, we're done. Copy the temp buffer back into the line buffer */
363	strcpy(LineBuffer, TempBuffer);
364
365	}
366