[apple/system_cmds.git] / kmodload.tproj / vers_rsrc.c

#include "vers_rsrc.h"

int vers_isdigit(char c) {
    return (c == '0' ||
        c == '1' || c == '2' || c == '3' ||
        c == '4' || c == '5' || c == '6' ||
        c == '7' || c == '8' || c == '9');
}

int vers_isspace(char c) {
    return (c == ' ' ||
        c == '\t' ||
        c == '\r' ||
        c == '\n');
}


int isreleasestate(char c) {
    return (c == 'd' || c == 'a' || c == 'b' || c == 'f');
}


UInt8 BCD_digit_for_char(char c) {
    switch (c) {
      case '0': return 0; break;
      case '1': return 1; break;
      case '2': return 2; break;
      case '3': return 3; break;
      case '4': return 4; break;
      case '5': return 5; break;
      case '6': return 6; break;
      case '7': return 7; break;
      case '8': return 8; break;
      case '9': return 9; break;
      default:  return BCD_illegal; break;
    }
    return BCD_illegal;
}


char BCD_char_for_digit(UInt8 digit) {
    switch (digit) {
      case 0:  return '0'; break;
      case 1:  return '1'; break;
      case 2:  return '2'; break;
      case 3:  return '3'; break;
      case 4:  return '4'; break;
      case 5:  return '5'; break;
      case 6:  return '6'; break;
      case 7:  return '7'; break;
      case 8:  return '8'; break;
      case 9:  return '9'; break;
      default: return '?'; break;
    }
    return '?';
}


VERS_revision VERS_revision_for_string(char ** string_p) {
    char * string;

    if (!string_p || !*string_p) {
        return VERS_invalid;
    }

    string = *string_p;

    if (vers_isspace(string[0]) || string[0] == '\0') {
        return VERS_release;
    } else {
        switch (string[0]) {
          case 'd':
              if (vers_isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_development;
              }
              break;
          case 'a':
              if (vers_isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_alpha;
              }
              break;
          case 'b':
              if (vers_isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_beta;
              }
              break;
          case 'f':
              if (vers_isdigit(string[1])) {
                  *string_p = &string[1];
                  return VERS_candidate;
              } else if (string[1] == 'c' && vers_isdigit(string[2])) {
                  *string_p = &string[2];
                  return VERS_candidate;
              } else {
                  return VERS_invalid;
              }
              break;
          default:
              return VERS_invalid;
              break;
        }
    }

    return VERS_invalid;
}


int VERS_parse_string(char * vers_string, UInt32 * version_num) {
    int result = 1;
    VERS_version vers;
    char * current_char_p;
    UInt8  scratch;

    if (!vers_string || *vers_string == '\0') {
        return 0;
    }

    vers.vnum = 0;

    current_char_p = &vers_string[0];


   /*****
    * Check for an initial digit of the major release number.
    */
    vers.bytes[0] = BCD_digit_for_char(*current_char_p);
    if (vers.bytes[0] == BCD_illegal) {
        return 0;
    }

    current_char_p++;


   /*****
    * Check for a second digit of the major release number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (vers_isdigit(*current_char_p)) {
        scratch = BCD_digit_for_char(*current_char_p);
        if (scratch == BCD_illegal) {
            return 0;
        }
        vers.bytes[0] = BCD_combine(vers.bytes[0], scratch);
        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else if (*current_char_p == '.') {
            current_char_p++;
        } else {
            return 0;
        }
    } else if (isreleasestate(*current_char_p)) {
        goto release_state;
    } else if (*current_char_p == '.') {
        current_char_p++;
    } else {
        return 0;
    }


   /*****
    * Check for the minor release number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (vers_isdigit(*current_char_p)) {
        vers.bytes[1] = BCD_digit_for_char(*current_char_p);
        if (vers.bytes[1] == BCD_illegal) {
            return 0;
        }

        // Make sure its the first nibble of byte 1!
        vers.bytes[1] = BCD_combine(vers.bytes[1], 0);

        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else if (*current_char_p == '.') {
            current_char_p++;
        } else {
            return 0;
        }
    } else {
        return 0;
    }


   /*****
    * Check for the bugfix number.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else if (vers_isdigit(*current_char_p)) {
        scratch = BCD_digit_for_char(*current_char_p);
        if (scratch == BCD_illegal) {
            return 0;
        }

        /* vers.bytes[1] has its left nibble set already */
        vers.bytes[1] = vers.bytes[1] | scratch;

        current_char_p++;

        if (*current_char_p == '\0') {
            vers.bytes[2] = VERS_release;
            vers.bytes[3] = 0xff;
            goto finish;
        } else if (isreleasestate(*current_char_p)) {
            goto release_state;
        } else {
            return 0;
        }
    } else {
        return 0;
    }


release_state:

   /*****
    * Check for the release state.
    */
    if (*current_char_p == '\0') {
        vers.bytes[2] = VERS_release;
        vers.bytes[3] = 0xff;
        goto finish;
    } else {
        vers.bytes[2] = VERS_revision_for_string(&current_char_p);
        if (vers.bytes[2] == VERS_invalid) {
            return 0;
        }
    }


   /*****
    * Get the nonrelease revision number (0..255).
    */
    if (vers.bytes[2] != VERS_release) {
        UInt32 revision_num = 0;
        int    i;

        if (*current_char_p == '\0' || !vers_isdigit(*current_char_p)) {
            return 0;
        }
        for (i = 0; i < 3 && *current_char_p != '\0'; i++, current_char_p++) {
            UInt8 scratch_digit;
            scratch_digit = BCD_digit_for_char(*current_char_p);
            if (scratch_digit == BCD_illegal) {
                return 0;
            }
            revision_num *= 10;
            revision_num += scratch_digit;
        }
        if (vers_isdigit(*current_char_p) || revision_num > 255) {
            return 0;
        }
        vers.bytes[3] = (UInt8)revision_num;
    }

    if (vers.bytes[2] == VERS_release) {
        vers.bytes[3] = 0xff;
    } else {
        if (vers.bytes[2] == VERS_candidate) {
            if (vers.bytes[3] == 0) {
                return 0;
            } else {
                vers.bytes[2] = VERS_release;
                vers.bytes[3]--;
            }
        }
    }

finish:
    *version_num = CFSwapInt32BigToHost(vers.vnum);
    return result;
}


#define VERS_STRING_MAX_LEN  (12)

int VERS_string(char * buffer, UInt32 length, UInt32 vers) {
    VERS_version version;
    int cpos = 0;
    int result = 1;  // assume success

    char major1;
    char major2;
    char minor;
    char bugfix;

    version.vnum = CFSwapInt32HostToBig(vers);

   /* No buffer or length less than longest possible vers string,
    * return 0.
    */
    if (!buffer || length < VERS_STRING_MAX_LEN) {
        result = 0;
        goto finish;
    }

    bzero(buffer, length * sizeof(char));


   /*****
    * Major version number.
    */
    major1 = BCD_char_for_digit(BCD_get_left(version.bytes[0]));
    if (major1 == '?') {
        result = 0;
    } /* this is not an 'else' situation */
    if (major1 != '0') {
        buffer[cpos] = major1;
        cpos++;
    }

    major2 = BCD_char_for_digit(BCD_get_right(version.bytes[0]));
    if (major2 == '?') {
        result = 0;
    }

    buffer[cpos] = major2;
    cpos++;


   /*****
    * Minor & bug-fix version numbers.
    */
    minor = BCD_char_for_digit(BCD_get_left(version.bytes[1]));
    if (minor == '?') {
        result = 0;
    }
    bugfix = BCD_char_for_digit(BCD_get_right(version.bytes[1]));
    if (bugfix == '?') {
        result = 0;
    }


   /* Always display the minor version number.
    */
    buffer[cpos] = '.';
    cpos++;
    buffer[cpos] = minor;
    cpos++;


   /* Only display the bugfix version number if it's nonzero.
    */
    if (bugfix != '0') {
        buffer[cpos] = '.';
        cpos++;
        buffer[cpos] = bugfix;
        cpos++;
    }


   /* If the release state is final, we're done!
    */
    if (version.bytes[2] == VERS_release && version.bytes[3] == 255) {
        goto finish;
    }


   /*****
    * Do the release state and update level.
    */
    switch (version.bytes[2]) {
      case VERS_development:
        buffer[cpos] = 'd';
        cpos++;
        break;
      case VERS_alpha:
        buffer[cpos] = 'a';
        cpos++;
        break;
      case VERS_beta:
        buffer[cpos] = 'b';
        cpos++;
        break;
      case VERS_release:
        if (version.bytes[3] < 255) {
            buffer[cpos] = 'f';
            buffer[cpos+1] = 'c';
            cpos += 2;
        } else {
            goto finish;
        }
        break;
      default:
        result = 0;
        buffer[cpos] = '?';
        cpos++;
        break;
    }

    if (version.bytes[2] != VERS_release) {
        sprintf(&buffer[cpos], "%d", version.bytes[3]);
    } else {
        if (version.bytes[3] < 255) {
            sprintf(&buffer[cpos], "%d", version.bytes[3] + 1);
        }
    }

finish:
    return result;
}
Commit	Line	Data
916eb79e A	1	#include "vers_rsrc.h"
	2
	3	int vers_isdigit(char c) {
	4	return (c == '0' \|\|
	5	c == '1' \|\| c == '2' \|\| c == '3' \|\|
	6	c == '4' \|\| c == '5' \|\| c == '6' \|\|
	7	c == '7' \|\| c == '8' \|\| c == '9');
	8	}
	9
	10	int vers_isspace(char c) {
	11	return (c == ' ' \|\|
	12	c == '\t' \|\|
	13	c == '\r' \|\|
	14	c == '\n');
	15	}
	16
	17
	18	int isreleasestate(char c) {
	19	return (c == 'd' \|\| c == 'a' \|\| c == 'b' \|\| c == 'f');
	20	}
	21
	22
	23	UInt8 BCD_digit_for_char(char c) {
	24	switch (c) {
	25	case '0': return 0; break;
	26	case '1': return 1; break;
	27	case '2': return 2; break;
	28	case '3': return 3; break;
	29	case '4': return 4; break;
	30	case '5': return 5; break;
	31	case '6': return 6; break;
	32	case '7': return 7; break;
	33	case '8': return 8; break;
	34	case '9': return 9; break;
	35	default: return BCD_illegal; break;
	36	}
	37	return BCD_illegal;
	38	}
	39
	40
	41	char BCD_char_for_digit(UInt8 digit) {
	42	switch (digit) {
	43	case 0: return '0'; break;
	44	case 1: return '1'; break;
	45	case 2: return '2'; break;
	46	case 3: return '3'; break;
	47	case 4: return '4'; break;
	48	case 5: return '5'; break;
	49	case 6: return '6'; break;
	50	case 7: return '7'; break;
	51	case 8: return '8'; break;
	52	case 9: return '9'; break;
	53	default: return '?'; break;
	54	}
	55	return '?';
	56	}
	57
	58
	59	VERS_revision VERS_revision_for_string(char ** string_p) {
	60	char * string;
	61
	62	if (!string_p \|\| !*string_p) {
	63	return VERS_invalid;
	64	}
65
66	string = *string_p;
67
68	if (vers_isspace(string[0]) \|\| string[0] == '\0') {
69	return VERS_release;
70	} else {
71	switch (string[0]) {
72	case 'd':
73	if (vers_isdigit(string[1])) {
74	*string_p = &string[1];
75	return VERS_development;
76	}
77	break;
78	case 'a':
79	if (vers_isdigit(string[1])) {
80	*string_p = &string[1];
81	return VERS_alpha;
82	}
83	break;
84	case 'b':
85	if (vers_isdigit(string[1])) {
86	*string_p = &string[1];
87	return VERS_beta;
88	}
89	break;
90	case 'f':
91	if (vers_isdigit(string[1])) {
92	*string_p = &string[1];
93	return VERS_candidate;
94	} else if (string[1] == 'c' && vers_isdigit(string[2])) {
95	*string_p = &string[2];
96	return VERS_candidate;
97	} else {
98	return VERS_invalid;
99	}
100	break;
101	default:
102	return VERS_invalid;
103	break;
104	}
105	}
106
107	return VERS_invalid;
108	}
109
110
111	int VERS_parse_string(char * vers_string, UInt32 * version_num) {
112	int result = 1;
113	VERS_version vers;
114	char * current_char_p;
115	UInt8 scratch;
116
117	if (!vers_string \|\| *vers_string == '\0') {
118	return 0;
119	}
120
121	vers.vnum = 0;
122
123	current_char_p = &vers_string[0];
124
125
126	/*****
127	* Check for an initial digit of the major release number.
128	*/
129	vers.bytes[0] = BCD_digit_for_char(*current_char_p);
130	if (vers.bytes[0] == BCD_illegal) {
131	return 0;
132	}
133
134	current_char_p++;
135
136
137	/*****
138	* Check for a second digit of the major release number.
139	*/
140	if (*current_char_p == '\0') {
141	vers.bytes[2] = VERS_release;
142	vers.bytes[3] = 0xff;
143	goto finish;
144	} else if (vers_isdigit(*current_char_p)) {
145	scratch = BCD_digit_for_char(*current_char_p);
146	if (scratch == BCD_illegal) {
147	return 0;
148	}
149	vers.bytes[0] = BCD_combine(vers.bytes[0], scratch);
150	current_char_p++;
151
152	if (*current_char_p == '\0') {
153	vers.bytes[2] = VERS_release;
154	vers.bytes[3] = 0xff;
155	goto finish;
156	} else if (isreleasestate(*current_char_p)) {
157	goto release_state;
158	} else if (*current_char_p == '.') {
159	current_char_p++;
160	} else {
161	return 0;
162	}
163	} else if (isreleasestate(*current_char_p)) {
164	goto release_state;
165	} else if (*current_char_p == '.') {
166	current_char_p++;
167	} else {
168	return 0;
169	}
170
171
172	/*****
173	* Check for the minor release number.
174	*/
175	if (*current_char_p == '\0') {
176	vers.bytes[2] = VERS_release;
177	vers.bytes[3] = 0xff;
178	goto finish;
179	} else if (vers_isdigit(*current_char_p)) {
180	vers.bytes[1] = BCD_digit_for_char(*current_char_p);
181	if (vers.bytes[1] == BCD_illegal) {
182	return 0;
183	}
184
185	// Make sure its the first nibble of byte 1!
186	vers.bytes[1] = BCD_combine(vers.bytes[1], 0);
187
188	current_char_p++;
189
190	if (*current_char_p == '\0') {
191	vers.bytes[2] = VERS_release;
192	vers.bytes[3] = 0xff;
193	goto finish;
194	} else if (isreleasestate(*current_char_p)) {
195	goto release_state;
196	} else if (*current_char_p == '.') {
197	current_char_p++;
198	} else {
199	return 0;
200	}
201	} else {
202	return 0;
203	}
204
205
206	/*****
207	* Check for the bugfix number.
208	*/
209	if (*current_char_p == '\0') {
210	vers.bytes[2] = VERS_release;
211	vers.bytes[3] = 0xff;
212	goto finish;
213	} else if (vers_isdigit(*current_char_p)) {
214	scratch = BCD_digit_for_char(*current_char_p);
215	if (scratch == BCD_illegal) {
216	return 0;
217	}
218
219	/* vers.bytes[1] has its left nibble set already */
220	vers.bytes[1] = vers.bytes[1] \| scratch;
221
222	current_char_p++;
223
224	if (*current_char_p == '\0') {
225	vers.bytes[2] = VERS_release;
226	vers.bytes[3] = 0xff;
227	goto finish;
228	} else if (isreleasestate(*current_char_p)) {
229	goto release_state;
230	} else {
231	return 0;
232	}
233	} else {
234	return 0;
235	}
236
237
238	release_state:
239
240	/*****
241	* Check for the release state.
242	*/
243	if (*current_char_p == '\0') {
244	vers.bytes[2] = VERS_release;
245	vers.bytes[3] = 0xff;
246	goto finish;
247	} else {
248	vers.bytes[2] = VERS_revision_for_string(&current_char_p);
249	if (vers.bytes[2] == VERS_invalid) {
250	return 0;
251	}
252	}
253
254
255	/*****
256	* Get the nonrelease revision number (0..255).
257	*/
258	if (vers.bytes[2] != VERS_release) {
259	UInt32 revision_num = 0;
260	int i;
261
262	if (current_char_p == '\0' \|\| !vers_isdigit(current_char_p)) {
263	return 0;
264	}
265	for (i = 0; i < 3 && *current_char_p != '\0'; i++, current_char_p++) {
266	UInt8 scratch_digit;
267	scratch_digit = BCD_digit_for_char(*current_char_p);
268	if (scratch_digit == BCD_illegal) {
269	return 0;
270	}
271	revision_num *= 10;
272	revision_num += scratch_digit;
273	}
274	if (vers_isdigit(*current_char_p) \|\| revision_num > 255) {
275	return 0;
276	}
277	vers.bytes[3] = (UInt8)revision_num;
278	}
279
280	if (vers.bytes[2] == VERS_release) {
281	vers.bytes[3] = 0xff;
282	} else {
283	if (vers.bytes[2] == VERS_candidate) {
284	if (vers.bytes[3] == 0) {
285	return 0;
286	} else {
287	vers.bytes[2] = VERS_release;
288	vers.bytes[3]--;
289	}
290	}
291	}
292
293	finish:
294	*version_num = CFSwapInt32BigToHost(vers.vnum);
295	return result;
296	}
297
298
299	#define VERS_STRING_MAX_LEN (12)
300
301	int VERS_string(char * buffer, UInt32 length, UInt32 vers) {
302	VERS_version version;
303	int cpos = 0;
304	int result = 1; // assume success
305
306	char major1;
307	char major2;
308	char minor;
309	char bugfix;
310
311	version.vnum = CFSwapInt32HostToBig(vers);
312
313	/* No buffer or length less than longest possible vers string,
314	* return 0.
315	*/
316	if (!buffer \|\| length < VERS_STRING_MAX_LEN) {
317	result = 0;
318	goto finish;
319	}
320
321	bzero(buffer, length * sizeof(char));
322
323
324	/*****
325	* Major version number.
326	*/
327	major1 = BCD_char_for_digit(BCD_get_left(version.bytes[0]));
328	if (major1 == '?') {
329	result = 0;
330	} /* this is not an 'else' situation */
331	if (major1 != '0') {
332	buffer[cpos] = major1;
333	cpos++;
334	}
335
336	major2 = BCD_char_for_digit(BCD_get_right(version.bytes[0]));
337	if (major2 == '?') {
338	result = 0;
339	}
340
341	buffer[cpos] = major2;
342	cpos++;
343
344
345	/*****
346	* Minor & bug-fix version numbers.
347	*/
348	minor = BCD_char_for_digit(BCD_get_left(version.bytes[1]));
349	if (minor == '?') {
350	result = 0;
351	}
352	bugfix = BCD_char_for_digit(BCD_get_right(version.bytes[1]));
353	if (bugfix == '?') {
354	result = 0;
355	}
356
357
358	/* Always display the minor version number.
359	*/
360	buffer[cpos] = '.';
361	cpos++;
362	buffer[cpos] = minor;
363	cpos++;
364
365
366	/* Only display the bugfix version number if it's nonzero.
367	*/
368	if (bugfix != '0') {
369	buffer[cpos] = '.';
370	cpos++;
371	buffer[cpos] = bugfix;
372	cpos++;
373	}
374
375
376	/* If the release state is final, we're done!
377	*/
378	if (version.bytes[2] == VERS_release && version.bytes[3] == 255) {
379	goto finish;
380	}
381
382
383	/*****
384	* Do the release state and update level.
385	*/
386	switch (version.bytes[2]) {
387	case VERS_development:
388	buffer[cpos] = 'd';
389	cpos++;
390	break;
391	case VERS_alpha:
392	buffer[cpos] = 'a';
393	cpos++;
394	break;
395	case VERS_beta:
396	buffer[cpos] = 'b';
397	cpos++;
398	break;
399	case VERS_release:
400	if (version.bytes[3] < 255) {
401	buffer[cpos] = 'f';
402	buffer[cpos+1] = 'c';
403	cpos += 2;
404	} else {
405	goto finish;
406	}
407	break;
408	default:
409	result = 0;
410	buffer[cpos] = '?';
411	cpos++;
412	break;
413	}
414
415	if (version.bytes[2] != VERS_release) {
416	sprintf(&buffer[cpos], "%d", version.bytes[3]);
417	} else {
418	if (version.bytes[3] < 255) {
419	sprintf(&buffer[cpos], "%d", version.bytes[3] + 1);
420	}
421	}
422
423	finish:
424	return result;
425	}