about summary refs log tree commit diff stats
path: root/numericx.c
blob: be2042230d7ba094e3b752282aa94feaca00617d (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
/** @file numericx.c
 * Numericx library implementation.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include "numericx.h"


/* ||FUNCTIONS|| */

/**
 * @brief Create new digit for numeral_ptr.
 *
 * It needs the last_numeral ('last_numeral') into which will
 * add the new numeral, and also need to know the symbol of the
 * new numeral ('to_first').
 *
 * @param last_numeral - last numeral_ptr* into which new numeral_ptr will be added.
 * @param to_first - the symbol of the new digit.
 *
 * @return pointer to new numeral_ptr in case of success.
 * @return NULL in case of no memory.
 */
static numeral_ptr*
new_digit(numeral_ptr* last_numeral, char const* to_first)
{
	numeral_ptr* new_numeral = malloc(sizeof(numeral_ptr));
	if(new_numeral == NULL)
	{
		fprintf(stderr, "error: %s: %s!", PROG_NAME, strerror(ENOMEM));
		return NULL;
	}

	new_numeral->symbol = to_first;
	new_numeral->previous = last_numeral;
	new_numeral->next = NULL;

	return new_numeral;
}

/**
 * @brief Initializer of numeral_ptr
 *
 * Creates a number of the form numeral_ptr that
 * begins with 'case' number of cases, and all cases
 * are set to 'to_first' char.
 *
 * @param to_first - the symbol of the cases for the new number.
 * @param cases - number of cases of the new number.
 *
 * @return pointer to numeral_ptr in case of success.
 * @return NULL in case of no memory ( because depends
 * on new_digit() ).
 */
static numeral_ptr*
numeral_infinity(char const* to_first, size_t cases)
{
	numeral_ptr* starting_case = new_digit(NULL, to_first);
	numeral_ptr* other_case = starting_case;

	for(size_t i = 2; i <= cases; ++i)
	{
		other_case->next = new_digit(other_case, to_first);
		other_case = other_case->next;
	}

	return starting_case;
}

/**
 * @brief Increment numeral_ptr 'numeral' one unit up.
 *
 * It needs 'num_first' as the first numeral of the numerical
 * system. Also needs 'num_last' as the last numeral of the
 * numerical system.
 * When incrementing, if the function adds a new digit/numeral, it
 * will use the 'brand_new_digit' as its new numeral/digit.
 *
 * @param numeral - numeral to increment.
 * @param num_first - number's numeral system first numeral.
 * @param num_last - number's numeral system last numeral.
 * @param brand_new_digit - brand new created numeral, if needed by incrementation.
 */
static void
increment(numeral_ptr* numeral, char* num_first, char* num_last, char* brand_new_digit)
{
	bool cycled = false;

	if( numeral->symbol == num_last )
	{
		if( numeral->next == NULL )
			numeral->next = new_digit(numeral, brand_new_digit);
		else
			increment(numeral->next, num_first, num_last, brand_new_digit);

		cycled = true;
	}

	if( cycled )
		numeral->symbol = num_first;
	else
		++(numeral->symbol);
}

/**
 * @brief Decrement a string 'number' by one unit.
 *
 * It needs to know the first numeral ('first_numeral') and also the
 * last numeral ('last_numeral'). It also needs the numeral system in
 * form of a string ('numeral_system') to know which is the numeral,
 * before the actual numeral, that needs decrementation.
 *
 * @param number - the string number to be decremented.
 * @param first_numeral - number's numeral system first numeral.
 * @param last_numeral - number's numeral system last numeral.
 * @param numeral_system - string of the corresponding number's numeral system numeral.
 */
static void
decrement_number_string(char* number, char* first_numeral, char* last_numeral, char* numeral_system)
{
	while( *number == *first_numeral )
	{
		*number = *last_numeral;
		++number;
	}

	if( *number == '\0' )
	{
		*(--number) = '\0';
	}
	else
	{
		while( !(*numeral_system == *number) )
			++numeral_system;

		*number = *(--numeral_system);
	}
}

/**
 * @brief Check if numeral_ptr and string are of the same value
 *
 * Compares if a numeral_ptr ('numeral') matches the string ('number_arg').
 *
 * @param numeral - numeral_ptr to check.
 * @param number_arg - string to check.
 *
 * @return true if matches.
 * @return false if doesn't match.
 */
static bool
is_the_same(numeral_ptr* numeral, char* number_arg)
{
	while( !(numeral == NULL) )
	{
		if( *(numeral->symbol) == *(number_arg) )
		{
			numeral = numeral->next;
			++(number_arg);
			continue;
		}

		return false;
	}

	return (*number_arg == '\0') ? true : false;
}

/**
 * @brief Reverse a string.
 *
 * @param string - string to be reversed.
 */
static void
reverse_string(char* string)
{
	char tmp;
	char* string_end = string + strlen(string);

	while ( --string_end > string )
	{
		tmp = *string;
		*string++ = *string_end;
		*string_end = tmp;
	}
}

/**
 * @brief Does string belongs to numeral system?
 *
 * Check if string 'number' belongs to the numerical
 * system ('numeral_system'), which is also a string.
 * Belonging mean all the symbols of 'number' are included
 * in 'numeral_system'.
 *
 * @param numeral_system - numeral system string to check against.
 * @param number - number to see if belongs.
 *
 * @return true if it belongs.
 * @return false if it doesn't belong.
 */
static bool
is_valid_number(char* numeral_system, char *number)
{
	/*
	if( *number == '-' || *number == '+' )
		++number;
	*/
	while( !(*number == '\0') )
	{
		if( strchr(numeral_system, *number) == NULL )
			return false;
		++number;
	}

	return true;
}

/**
 * @brief Free numeral memory.
 *
 * Free up numeral_ptr ('numeral') linked chain.
 *
 * @param numeral - numeral_ptr to free.
 */
static void
free_numeral(numeral_ptr* numeral)
{
	numeral_ptr* tmp = NULL;

	while( !(numeral == NULL) )
	{
		tmp = numeral->next;
		free(numeral);
		numeral = tmp;
	}
}

/**
 * @brief Free numericx result.
 *
 * Free up the result string of numericx_translate(),
 * after we are done with it.
 *
 * @param string - char pointer to be free.
 */
void
numericx_free(char* string)
{
	free(string);
}

/**
 * @brief Convert numeral_ptr to string.
 *
 * Allocates space for string and converts numeral_ptr* to char*.
 *
 * @param numeral - numeral_ptr to be converted to string.
 * @param result_with_units_on_the_end - define if result has units on the end.
 *
 * @return char pointer to converted string, in case of success.
 * @return NULL in case of no memory.
 */
static char*
numeral_to_string(numeral_ptr* numeral, bool result_with_units_on_the_end)
{
	size_t length = 1;
	numeral_ptr* numeral_last = numeral;

	while( !(numeral_last->next == NULL) )
	{
		++length;
		numeral_last = numeral_last->next;
	}

	char* result = malloc((length + 1) * sizeof(char));
	char* tmp = result;

	if( !result_with_units_on_the_end )
	{
		for( numeral_ptr* digit = numeral;
				!(digit == NULL); digit = digit->next)
		{
			*tmp = *(digit->symbol);
			++tmp;
		}
	}
	else
	{
		for( numeral_ptr* digit = numeral_last;
				!(digit == NULL); digit = digit->previous)
		{
			*tmp = *(digit->symbol);
			++tmp;
		}
	}

	*(tmp) = '\0';

	return result;
}

/**
 * @brief Translate string to a different numerical system.
 *
 * After definition of the 'from' numerical system proprieties and the
 * 'to' numerical system proprieties, will be translate 'number' from the
 * 'from' to the 'to' numerical system, resulting in a string.
 *
 * @param from - string with all the numerals of the number's numerical system.
 * @param from_units_on_the_end - does the translate 'from' numerical system have units on the end (on the right)?
 * @param from_first_number_void - does the translate 'from' numerical system start counting on the second number?
 * @param from_infinite_base - is the translate 'from' numerical system first numeral infinite? For example, if first numeral is 'A', then does 'A' == 'AA' == 'AAA' == 'AAAA' ... ?
 * @param to - string with all the numerals of the resulting number's numerical system.
 * @param to_units_on_the_end - does the translate 'to' numerical system have units on the end (on the right)?
 * @param to_first_number_void - does the translate 'to' numerical system start counting on the second number?
 * @param to_infinite_base - is the translate 'to' numerical system first numeral infinite? For example, if first numeral is 'A', then does 'A' == 'AA' == 'AAA' == 'AAAA' ... ?
 * @param number - number of the 'from' numerical system, to be translated into the 'to' numerical system.
 * @param result_string - string to where to store the result.
 *
 * @return EINVAL if argument of result_string is not NULL.
 * @return EDOM if number doesn't belong to the 'from' numerical system.
 * @return ERANGE if the resulting number cannot be represented, because of a 'from' void number and a lack of void number in 'to'.
 * @return EXIT_SUCCESS in case of success.
 */
int
numericx_translate(char* from, bool from_units_on_the_end, bool from_first_number_void, bool from_infinite_base, char* to, bool to_units_on_the_end, bool to_first_number_void, bool to_infinite_base, char* number, char** result_string)
{
	/* result_string has to be NULL */
	if( !(*result_string == NULL) )
		return EINVAL;

	/* Check if number belongs to it's numerical system */
	if( !is_valid_number(from, number) )
		return EDOM;

	/* _first and _last variables */
	char* from_first = from;
	char* from_last = from + (strlen(from) - 1);

	char* to_first = to;
	char* to_last = to + (strlen(to) - 1);

	if( from_units_on_the_end )
	{
		reverse_string(number);
	}

	/* initializing counting and result */
	numeral_ptr* counting = NULL;
	numeral_ptr* result = NULL;

	if( from_infinite_base )
		counting = numeral_infinity(from_first, strlen(number));
	else
		counting = numeral_infinity(from_first, 1);

	result = numeral_infinity(to_first, 1);

	/* first number void */
	if( !(from_first_number_void && to_first_number_void) )
	{
		if( from_first_number_void )
		{
			if( strlen(number) == 1 && *number == *from_first )
			{
				free_numeral(counting);
				free_numeral(result);
				return ERANGE;
			}

			decrement_number_string(number, from_first, from_last, from_first);
		}

		if( to_first_number_void )
			increment(result, to_first, to_last, to_first);
	}

	/* minor optimization for the cycle below */
	char* to_second = NULL;

	if( to_infinite_base )
		to_second = to_first + 1;

	/* increments until it finishes */
	while( !is_the_same(counting, number) )
	{
		if( to_infinite_base )
			increment(result, to_first, to_last, to_second);
		else
			increment(result, to_first, to_last, to_first);

		increment(counting, from_first, from_last, from_first);
	}

	/* result to string (result_string) */
	*result_string = numeral_to_string(result, to_units_on_the_end);

	/* free memory */
	free_numeral(counting);
	free_numeral(result);

	return EXIT_SUCCESS;
}