fixes for Power64
[tridge/junkcode.git] / mangle.c
1 #include <stdio.h>
2
3 typedef int BOOL;
4 typedef char pstring[1024];
5 #define True 1
6 #define False 0
7 #define DEBUG(l,x)
8
9 /****************************************************************************
10 line strncpy but always null terminates. Make sure there is room!
11 ****************************************************************************/
12 char *StrnCpy(char *dest,char *src,int n)
13 {
14   char *d = dest;
15   while (n-- && (*d++ = *src++)) ;
16   *d = 0;
17   return(dest);
18 }
19
20 /*******************************************************************
21   convert a string to upper case
22 ********************************************************************/
23 void strupper(char *s)
24 {
25   while (*s)
26     {
27 #ifdef KANJI
28         if (is_shift_jis (*s)) {
29             s += 2;
30         } else if (is_kana (*s)) {
31             s++;
32         } else {
33             if (islower(*s))
34                 *s = toupper(*s);
35             s++;
36         }
37 #else
38       if (islower(*s))
39         *s = toupper(*s);
40       s++;
41 #endif
42     }
43 }
44
45
46 static char *map_filename(char *s, /* This is null terminated */
47                           char *pattern, /* This isn't. */
48                           int len) /* This is the length of pattern. */
49 {
50   static pstring matching_bit;  /* The bit of the string which matches */
51                                 /* a * in pattern if indeed there is a * */
52   char *sp;                     /* Pointer into s. */
53   char *pp;                     /* Pointer into p. */
54   char *match_start;            /* Where the matching bit starts. */
55   pstring pat;
56
57   StrnCpy(pat, pattern, len);   /* Get pattern into a proper string! */
58   strcpy(matching_bit,"");      /* Match but no star gets this. */
59   pp = pat;                     /* Initialise the pointers. */
60   sp = s;
61   if ((len == 1) && (*pattern == '*')) {
62     return NULL;                /* Impossible, too ambiguous for */
63                                 /* words! */
64   }
65
66   while ((*sp)                  /* Not the end of the string. */
67          && (*pp)               /* Not the end of the pattern. */
68          && (*sp == *pp)        /* The two match. */
69          && (*pp != '*')) {     /* No wildcard. */
70     sp++;                       /* Keep looking. */
71     pp++;
72   }
73   if (!*sp && !*pp)             /* End of pattern. */
74     return matching_bit;        /* Simple match.  Return empty string. */
75   if (*pp == '*') {
76     pp++;                       /* Always interrested in the chacter */
77                                 /* after the '*' */
78     if (!*pp) {                 /* It is at the end of the pattern. */
79       StrnCpy(matching_bit, s, sp-s);
80       return matching_bit;
81     } else {
82       /* The next character in pattern must match a character further */
83       /* along s than sp so look for that character. */
84       match_start = sp;
85       while ((*sp)              /* Not the end of s. */
86              && (*sp != *pp))   /* Not the same  */
87         sp++;                   /* Keep looking. */
88       if (!*sp) {               /* Got to the end without a match. */
89         return NULL;
90       } else {                  /* Still hope for a match. */
91         /* Now sp should point to a matching character. */
92         StrnCpy(matching_bit, match_start, sp-match_start);
93         /* Back to needing a stright match again. */
94         while ((*sp)            /* Not the end of the string. */
95                && (*pp)         /* Not the end of the pattern. */
96                && (*sp == *pp)) { /* The two match. */
97           sp++;                 /* Keep looking. */
98           pp++;
99         }
100         if (!*sp && !*pp)       /* Both at end so it matched */
101           return matching_bit;
102         else
103           return NULL;
104       }
105     }
106   }
107   return NULL;                  /* No match. */
108 }
109
110
111 static void do_fwd_mangled_map(char *s, char *MangledMap)
112 {
113   /* MangledMap is a series of name pairs in () separated by spaces.
114    * If s matches the first of the pair then the name given is the
115    * second of the pair.  A * means any number of any character and if
116    * present in the second of the pair as well as the first the
117    * matching part of the first string takes the place of the * in the
118    * second.
119    *
120    * I wanted this so that we could have RCS files which can be used
121    * by UNIX and DOS programs.  My mapping string is (RCS rcs) which
122    * converts the UNIX RCS file subdirectory to lowercase thus
123    * preventing mangling.
124    */
125   char *start=MangledMap;       /* Use this to search for mappings. */
126   char *end;                    /* Used to find the end of strings. */
127   char *match_string;
128   pstring new_string;           /* Make up the result here. */
129   char *np;                     /* Points into new_string. */
130
131   DEBUG(5,("Mangled Mapping '%s' map '%s'\n", s, MangledMap));
132   while (*start) {
133     while ((*start) && (*start != '('))
134       start++;
135     start++;                    /* Skip the ( */
136     if (!*start)
137       continue;                 /* Always check for the end. */
138     end = start;                /* Search for the ' ' or a ')' */
139     DEBUG(5,("Start of first in pair '%s'\n", start));
140     while ((*end) && !((*end == ' ') || (*end == ')')))
141       end++;
142     if (!*end) {
143       start = end;
144       continue;                 /* Always check for the end. */
145     }
146     DEBUG(5,("End of first in pair '%s'\n", end));
147     if ((match_string = map_filename(s, start, end-start))) {
148       DEBUG(5,("Found a match\n"));
149       /* Found a match. */
150       start = end+1;            /* Point to start of what it is to become. */
151       DEBUG(5,("Start of second in pair '%s'\n", start));
152       end = start;
153       np = new_string;
154       while ((*end)             /* Not the end of string. */
155              && (*end != ')')   /* Not the end of the pattern. */
156              && (*end != '*'))  /* Not a wildcard. */
157         *np++ = *end++;
158       if (!*end) {
159         start = end;
160         continue;               /* Always check for the end. */
161       }
162       if (*end == '*') {
163         strcpy(np, match_string);
164         np += strlen(match_string);
165         end++;                  /* Skip the '*' */
166         while ((*end)             /* Not the end of string. */
167                && (*end != ')')   /* Not the end of the pattern. */
168                && (*end != '*'))  /* Not a wildcard. */
169           *np++ = *end++;
170       }
171       if (!*end) {
172         start = end;
173         continue;               /* Always check for the end. */
174       }
175       *np++ = '\0';             /* NULL terminate it. */
176       DEBUG(5,("End of second in pair '%s'\n", end));
177       strcpy(s, new_string);    /* Substitute with the new name. */
178       DEBUG(5,("s is now '%s'\n", s));
179     }
180     start = end;              /* Skip a bit which cannot be wanted */
181     /* anymore. */
182     start++;
183   }
184 }
185
186
187 main(int argc,char *argv[])
188 {
189   char name[100];
190
191   strcpy(name,argv[2]);
192   
193   do_fwd_mangled_map(name,argv[1]);
194   printf("name=%s\n",name);
195 }