diff --git a/cgc-challenges/Accel/.frama-c/Accel.eva/alarms.csv b/cgc-challenges/Accel/.frama-c/Accel.eva/alarms.csv
new file mode 100644
index 0000000000000000000000000000000000000000..f581429401c495fda661a5144b2b5a7a3fb4de8a
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.eva/alarms.csv
@@ -0,0 +1,203 @@
+directory file line function property kind status property
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 100 cgc_init_sheet initialization Unknown \initialized(g_sheet + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 111 cgc_show_cell ptr_comparison Unknown \pointer_comparable((void *)cell, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 114 cgc_show_cell dangling_pointer Unknown ¬\dangling(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 114 cgc_show_cell initialization Unknown \initialized(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 114 cgc_show_cell mem_access Unknown \valid_read(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 120 cgc_show_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 120 cgc_show_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 120 cgc_show_cell mem_access Unknown \valid_read(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 122 cgc_show_cell dangling_pointer Unknown ¬\dangling(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 122 cgc_show_cell initialization Unknown \initialized(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 122 cgc_show_cell mem_access Unknown \valid_read(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 122 cgc_show_cell ptr_comparison Unknown \pointer_comparable((void *)cell->formula, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 124 cgc_show_cell dangling_pointer Unknown ¬\dangling(&cell->id)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 124 cgc_show_cell initialization Unknown \initialized(&cell->id)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 124 cgc_show_cell mem_access Unknown \valid_read(&cell->id)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 129 cgc_show_cell is_nan_or_infinite Unknown \is_finite(val)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 132 cgc_show_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 132 cgc_show_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 132 cgc_show_cell mem_access Unknown \valid_read(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 139 cgc_set_cell precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 139 cgc_set_cell precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 143 cgc_set_cell ptr_comparison Unknown \pointer_comparable((void *)cell, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 146 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 146 cgc_set_cell initialization Unknown \initialized(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 146 cgc_set_cell mem_access Unknown \valid_read(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 147 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 147 cgc_set_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 147 cgc_set_cell mem_access Unknown \valid_read(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 147 cgc_set_cell precondition of free Unknown freeable: p ≡ \null ∨ \freeable(p)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 148 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 148 cgc_set_cell mem_access Unknown \valid(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 149 cgc_set_cell mem_access Unknown \valid(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 150 cgc_set_cell mem_access Unknown \valid(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 153 cgc_set_cell mem_access Unknown \valid(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 153 cgc_set_cell precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 154 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 154 cgc_set_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 154 cgc_set_cell mem_access Unknown \valid_read(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 154 cgc_set_cell ptr_comparison Unknown \pointer_comparable((void *)cell->str, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 157 cgc_set_cell precondition of strcpy Unknown room_string: \valid(dest + (0 .. strlen(src)))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 157 cgc_set_cell precondition of strcpy Unknown valid_string_src: valid_read_string(src)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 158 cgc_set_cell precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 158 cgc_set_cell initialization Unknown \initialized(cell_str + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 158 cgc_set_cell mem_access Unknown \valid_read(cell_str + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 159 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 159 cgc_set_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 159 cgc_set_cell mem_access Unknown \valid(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 160 cgc_set_cell mem_access Unknown \valid(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 163 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 163 cgc_set_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 163 cgc_set_cell mem_access Unknown \valid(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 164 cgc_set_cell dangling_pointer Unknown ¬\dangling(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 164 cgc_set_cell initialization Unknown \initialized(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 164 cgc_set_cell mem_access Unknown \valid_read(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 176 cgc_clear_cell ptr_comparison Unknown \pointer_comparable((void *)cell, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 179 cgc_clear_cell dangling_pointer Unknown ¬\dangling(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 179 cgc_clear_cell initialization Unknown \initialized(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 179 cgc_clear_cell mem_access Unknown \valid_read(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 180 cgc_clear_cell dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 180 cgc_clear_cell initialization Unknown \initialized(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 180 cgc_clear_cell mem_access Unknown \valid_read(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 180 cgc_clear_cell precondition of free Unknown freeable: p ≡ \null ∨ \freeable(p)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 181 cgc_clear_cell dangling_pointer Unknown ¬\dangling(&cell)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 181 cgc_clear_cell mem_access Unknown \valid(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 182 cgc_clear_cell mem_access Unknown \valid(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 183 cgc_clear_cell mem_access Unknown \valid(&cell->formula)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 198 cgc_print_assigned_cells initialization Unknown \initialized(g_sheet + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 198 cgc_print_assigned_cells mem_access Unknown \valid_read(g_sheet + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 199 cgc_print_assigned_cells dangling_pointer Unknown ¬\dangling(&cell->cell_type)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 200 cgc_print_assigned_cells dangling_pointer Unknown ¬\dangling(&cell->id)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 cgc_print_assigned_cells dangling_pointer Unknown ¬\dangling(&cell->str)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 cgc_print_assigned_cells precondition of printf_va_1 Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 cgc_print_assigned_cells precondition of printf_va_1 Unknown valid_read_string(param1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 cgc_print_assigned_cells precondition of printf_va_1 Unknown valid_read_string(param2)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 printf_va_1 precondition Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 printf_va_1 precondition Unknown valid_read_string(param1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 205 printf_va_1 precondition Unknown valid_read_string(param2)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 213 cgc_get_op ptr_comparison Unknown \pointer_comparable((void *)name, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 216 cgc_get_op precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 217 cgc_get_op precondition of strcpy Unknown room_string: \valid(dest + (0 .. strlen(src)))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 217 cgc_get_op precondition of strcpy Unknown separation: \separated(dest + (0 .. strlen(src)), src + (0 .. strlen(src)))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 217 cgc_get_op precondition of strcpy Unknown valid_string_src: valid_read_string(src)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 218 cgc_get_op precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 220 cgc_get_op dangling_pointer Unknown ¬\dangling(upper_name + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 220 cgc_get_op initialization Unknown \initialized(upper_name + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 220 cgc_get_op mem_access Unknown \valid(upper_name + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 220 cgc_get_op mem_access Unknown \valid_read(upper_name + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 220 cgc_get_op precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 224 cgc_get_op precondition of strcmp Unknown valid_string_s2: valid_read_string(s2)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 237 cgc_parsearg ptr_comparison Unknown \pointer_comparable((void *)arg, (void *)0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 244 cgc_parsearg dangling_pointer Unknown ¬\dangling(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 244 cgc_parsearg initialization Unknown \initialized(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 244 cgc_parsearg mem_access Unknown \valid_read(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 246 cgc_parsearg signed_overflow Unknown is_double + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 248 cgc_parsearg signed_overflow Unknown is_double + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 249 cgc_parsearg signed_overflow Unknown has_negative + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 251 cgc_parsearg signed_overflow Unknown is_double + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 252 cgc_parsearg signed_overflow Unknown has_period + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 254 cgc_parsearg signed_overflow Unknown is_hard_string + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 256 cgc_parsearg signed_overflow Unknown is_soft_string + 1 ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 263 cgc_parsearg dangling_pointer Unknown ¬\dangling(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 263 cgc_parsearg initialization Unknown \initialized(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 263 cgc_parsearg mem_access Unknown \valid_read(arg)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 312 cgc_get_cell precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 314 cgc_get_cell float_to_int Unknown (double)row_idx + \mul_double((double)((int)((int)row_str[i] - 64)), tmp_1) < 2147483648
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 314 cgc_get_cell float_to_int Unknown -2147483649 < (double)row_idx + \mul_double((double)((int)((int)row_str[i] - 64)), tmp_1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 314 cgc_get_cell initialization Unknown \initialized(&row_str[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 316 cgc_get_cell signed_overflow Unknown -2147483648 ≤ row_idx - 1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 318 cgc_get_cell dangling_pointer Unknown ¬\dangling(g_sheet + row_idx)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 318 cgc_get_cell initialization Unknown \initialized(g_sheet + row_idx)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 318 cgc_get_cell mem_access Unknown \valid_read(g_sheet + row_idx)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accel.c 379 cgc_eval_formula postcondition Unknown \initialized(\old(is_bad_formula))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 36 cgc_strtrim precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 45 cgc_strtrim initialization Unknown \initialized(tmp_0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 45 cgc_strtrim mem_access Unknown \valid_read(tmp_0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 46 cgc_strtrim precondition of memcpy Unknown separation: \separated((char *)dest + (0 .. n - 1), (char *)src + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 46 cgc_strtrim precondition of memcpy Unknown valid_dest: valid_or_empty(dest, n)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 46 cgc_strtrim precondition of memcpy Unknown valid_src: valid_read_or_empty(src, n)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 54 cgc_strtrim initialization Unknown \initialized(str + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 70 cgc_valid_cell_id precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 77 cgc_valid_cell_id dangling_pointer Unknown ¬\dangling(input + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 77 cgc_valid_cell_id initialization Unknown \initialized(input + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 77 cgc_valid_cell_id mem_access Unknown \valid_read(input + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 77 cgc_valid_cell_id precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 82 cgc_valid_cell_id dangling_pointer Unknown ¬\dangling(input + 1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 82 cgc_valid_cell_id initialization Unknown \initialized(input + 1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 82 cgc_valid_cell_id mem_access Unknown \valid_read(input + 1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 82 cgc_valid_cell_id precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 95 cgc_valid_cell_id dangling_pointer Unknown ¬\dangling(input + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 95 cgc_valid_cell_id initialization Unknown \initialized(input + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 95 cgc_valid_cell_id mem_access Unknown \valid_read(input + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 113 cgc_get_rowcol precondition of strlen Unknown valid_string_s: valid_read_string(s)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 117 cgc_get_rowcol initialization Unknown \initialized(input + 0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 117 cgc_get_rowcol precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 122 cgc_get_rowcol initialization Unknown \initialized(input + 1)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 122 cgc_get_rowcol precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel accelio.c 135 cgc_get_rowcol initialization Unknown \initialized(input + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 50 cgc_ftoa is_nan_or_infinite Unknown \is_finite(tmp_6)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 50 cgc_ftoa is_nan_or_infinite Unknown \is_finite(\mul_double(tmp_6, tmp_7))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 67 cgc_ftoa mem_access Unknown \valid(str + tmp_10)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 73 cgc_ftoa float_to_int Unknown -2147483649 < value / e
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 73 cgc_ftoa float_to_int Unknown value / e < 2147483648
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 73 cgc_ftoa is_nan_or_infinite Unknown \is_finite(\div_double(value, e))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 74 cgc_ftoa is_nan_or_infinite Unknown \is_finite(\sub_double(value, \mul_double((double)digit, e)))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 74 cgc_ftoa is_nan_or_infinite Unknown \is_finite(\mul_double((double)digit, e))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 75 cgc_ftoa mem_access Unknown \valid(str + tmp_12)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 75 cgc_ftoa signed_overflow Unknown digit + (int)'0' ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel ftoa.c 81 cgc_ftoa mem_access Unknown \valid(str + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 43 cgc_itoa signed_overflow Unknown (int)'0' - (int)(value % base) ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 43 cgc_itoa signed_overflow Unknown -2147483648 ≤ (int)'0' - (int)(value % base)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 43 cgc_itoa signed_overflow Unknown -2147483648 ≤ value % base
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 43 cgc_itoa signed_overflow Unknown value % base ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 45 cgc_itoa signed_overflow Unknown (int)'0' + (int)(value % base) ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 45 cgc_itoa signed_overflow Unknown -2147483648 ≤ (int)'0' + (int)(value % base)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 45 cgc_itoa signed_overflow Unknown -2147483648 ≤ value % base
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 45 cgc_itoa signed_overflow Unknown value % base ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 47 cgc_itoa signed_overflow Unknown -2147483648 ≤ value / base
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 47 cgc_itoa signed_overflow Unknown value / base ≤ 2147483647
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 55 cgc_itoa mem_access Unknown \valid(str + tmp_2)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 59 cgc_itoa initialization Unknown \initialized(str + j)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel itoa.c 60 cgc_itoa initialization Unknown \initialized(str + i)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 60 cgc_readline initialization Unknown \initialized(&rx)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 62 cgc_readline initialization Unknown \initialized(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 62 cgc_readline mem_access Unknown \valid_read(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 67 cgc_readline initialization Unknown \initialized(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 67 cgc_readline mem_access Unknown \valid_read(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 69 cgc_readline initialization Unknown \initialized(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 69 cgc_readline mem_access Unknown \valid_read(line)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 91 cgc_parse_line initialization Unknown \initialized(&tmp[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 91 cgc_parse_line precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 93 cgc_parse_line precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 98 cgc_parse_line initialization Unknown \initialized(&tmp[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 98 cgc_parse_line precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 100 cgc_parse_line precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 107 cgc_parse_line initialization Unknown \initialized(&tmp[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 107 cgc_parse_line precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 109 cgc_parse_line precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 115 cgc_parse_line initialization Unknown \initialized(&tmp[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 115 cgc_parse_line precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 117 cgc_parse_line precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 126 cgc_parse_line initialization Unknown \initialized(&tmp[i])
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 126 cgc_parse_line precondition of toupper Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 129 cgc_parse_line precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 135 cgc_parse_line precondition of printf_va_2 Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 135 printf_va_2 precondition Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 137 cgc_parse_line precondition of printf_va_3 Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel main.c 137 printf_va_3 precondition Unknown valid_read_string(param0)
+/home/andr/git/oscs-pub3/cgc-challenges/lib common.c 44 strsep initialization Unknown \initialized(i)
+/home/andr/git/oscs-pub3/cgc-challenges/lib common.c 44 strsep mem_access Unknown \valid_read(i)
+/home/andr/git/oscs-pub3/cgc-challenges/lib libcgc.c 42 cgc_receive precondition of read Unknown buf_has_room: \valid((char *)buf + (0 .. count - 1))
+FRAMAC_SHARE/libc ctype.h 217 toupper precondition Unknown c_uchar_of_eof: (0 ≤ c ≤ 255) ∨ c ≡ -1
+FRAMAC_SHARE/libc stdlib.h 405 free precondition Unknown freeable: p ≡ \null ∨ \freeable(p)
+FRAMAC_SHARE/libc string.h 57 memcmp precondition Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+FRAMAC_SHARE/libc string.h 92 memcpy precondition Unknown valid_dest: valid_or_empty(dest, n)
+FRAMAC_SHARE/libc string.h 93 memcpy precondition Unknown valid_src: valid_read_or_empty(src, n)
+FRAMAC_SHARE/libc string.h 95 memcpy precondition Unknown separation: \separated((char *)dest + (0 .. n - 1), (char *)src + (0 .. n - 1))
+FRAMAC_SHARE/libc string.h 125 strlen precondition Unknown valid_string_s: valid_read_string(s)
+FRAMAC_SHARE/libc string.h 138 strcmp precondition Unknown valid_string_s2: valid_read_string(s2)
+FRAMAC_SHARE/libc string.h 351 strcpy precondition Unknown valid_string_src: valid_read_string(src)
+FRAMAC_SHARE/libc string.h 352 strcpy precondition Unknown room_string: \valid(dest + (0 .. strlen(src)))
+FRAMAC_SHARE/libc string.h 354 strcpy precondition Unknown separation: \separated(dest + (0 .. strlen(src)), src + (0 .. strlen(src)))
+FRAMAC_SHARE/libc unistd.h 1005 read precondition Unknown buf_has_room: \valid((char *)buf + (0 .. count - 1))
diff --git a/cgc-challenges/Accel/.frama-c/Accel.eva/metrics.log b/cgc-challenges/Accel/.frama-c/Accel.eva/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..5f4c7a7eef2515a4dae19ffcfe7e870a2bd699a5
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.eva/metrics.log
@@ -0,0 +1,80 @@
+[metrics] Eva coverage statistics
+=======================
+Syntactically reachable functions = 51 (out of 68)
+Semantically reached functions = 19
+Coverage estimation = 37.3%
+
+Unreached functions (32) =
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c>: cgc_eval_function;
+ cgc_infixtorpn; cgc_is_arg_arithmetic;
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/accelfunc.c>:
+ cgc_handle_op_abs; cgc_handle_op_add; cgc_handle_op_avg;
+ cgc_handle_op_cos; cgc_handle_op_count; cgc_handle_op_ln;
+ cgc_handle_op_log10; cgc_handle_op_max; cgc_handle_op_median;
+ cgc_handle_op_min; cgc_handle_op_power; cgc_handle_op_product;
+ cgc_handle_op_quotient; cgc_handle_op_sin; cgc_handle_op_sqrt;
+ cgc_handle_op_stddev; cgc_handle_op_subtract; cgc_handle_op_sum;
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/accelio.c>:
+ cgc_sanitize_formula;
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/atof.c>: cgc_atof;
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/queue.c>: cgc_clear_queue;
+ cgc_dequeue_copy; cgc_enqueue; cgc_enqueue_copy;
+ </home/andr/git/oscs-pub3/cgc-challenges/Accel/stack.c>: cgc_clear_stack;
+ cgc_peek_top; cgc_pop_copy; cgc_push; cgc_push_copy;
+[metrics] References to non-analyzed functions
+------------------------------------
+Function cgc_eval_formula calls cgc_push_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:395)
+Function cgc_eval_formula calls cgc_infixtorpn (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:396)
+Function cgc_eval_formula calls cgc_dequeue_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:405)
+Function cgc_eval_formula calls cgc_push (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:409)
+Function cgc_eval_formula calls cgc_eval_function (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:413)
+Function cgc_eval_formula calls cgc_push_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:417)
+Function cgc_eval_formula calls cgc_push_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:435)
+Function cgc_eval_formula calls cgc_push_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:437)
+Function cgc_eval_formula calls cgc_push_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:444)
+Function cgc_eval_formula calls cgc_pop_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:455)
+Function cgc_eval_formula calls cgc_atof (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:459)
+Function cgc_eval_formula calls cgc_clear_queue (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:468)
+Function cgc_eval_formula calls cgc_clear_queue (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:469)
+Function cgc_eval_formula calls cgc_clear_stack (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:470)
+Function cgc_eval_formula calls cgc_pop_copy (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:472)
+Initializer of operators references cgc_handle_op_avg (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:60)
+Initializer of operators references cgc_handle_op_count (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:61)
+Initializer of operators references cgc_handle_op_max (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:62)
+Initializer of operators references cgc_handle_op_median (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:63)
+Initializer of operators references cgc_handle_op_min (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:64)
+Initializer of operators references cgc_handle_op_stddev (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:65)
+Initializer of operators references cgc_handle_op_abs (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:66)
+Initializer of operators references cgc_handle_op_add (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:67)
+Initializer of operators references cgc_handle_op_cos (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:68)
+Initializer of operators references cgc_handle_op_ln (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:69)
+Initializer of operators references cgc_handle_op_log10 (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:70)
+Initializer of operators references cgc_handle_op_power (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:71)
+Initializer of operators references cgc_handle_op_product (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:72)
+Initializer of operators references cgc_handle_op_quotient (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:73)
+Initializer of operators references cgc_handle_op_sin (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:74)
+Initializer of operators references cgc_handle_op_sqrt (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:75)
+Initializer of operators references cgc_handle_op_subtract (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:76)
+Initializer of operators references cgc_handle_op_sum (at /home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:77)
+[metrics] Statements analyzed by Eva
+--------------------------
+943 stmts in analyzed functions, 817 stmts analyzed (86.6%)
+cgc_clear_cell: 12 stmts out of 12 (100.0%)
+cgc_get_cell: 22 stmts out of 22 (100.0%)
+cgc_get_op: 36 stmts out of 36 (100.0%)
+cgc_get_rowcol: 71 stmts out of 71 (100.0%)
+cgc_init_sheet: 33 stmts out of 33 (100.0%)
+cgc_parsearg: 101 stmts out of 101 (100.0%)
+cgc_print_assigned_cells: 25 stmts out of 25 (100.0%)
+cgc_print_table: 2 stmts out of 2 (100.0%)
+cgc_readline: 28 stmts out of 28 (100.0%)
+cgc_receive: 9 stmts out of 9 (100.0%)
+cgc_show_cell: 33 stmts out of 33 (100.0%)
+cgc_valid_cell_id: 72 stmts out of 72 (100.0%)
+cgc_parse_line: 140 stmts out of 146 (95.9%)
+cgc_itoa: 56 stmts out of 59 (94.9%)
+cgc_strtrim: 43 stmts out of 47 (91.5%)
+cgc_set_cell: 39 stmts out of 45 (86.7%)
+main: 28 stmts out of 33 (84.8%)
+cgc_ftoa: 67 stmts out of 85 (78.8%)
+cgc_eval_formula: 0 stmts out of 84 (0.0%)
diff --git a/cgc-challenges/Accel/.frama-c/Accel.eva/nonterm.log b/cgc-challenges/Accel/.frama-c/Accel.eva/nonterm.log
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/cgc-challenges/Accel/.frama-c/Accel.eva/warnings.log b/cgc-challenges/Accel/.frama-c/Accel.eva/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..ad17ded9957d7af10cf5f8650ed47bb82a7f92a4
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.eva/warnings.log
@@ -0,0 +1,53 @@
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:157:[eva:garbled-mix] warning: The specification of function strcpy has generated a garbled mix for assigns clause assigns clause *
+(dest + (0 .. strlen{Old}(src))).
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:157:[eva:garbled-mix] warning: The specification of function strcpy has generated a garbled mix for assigns clause assigns clause \result.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accelio.c:77:[eva:garbled-mix] warning: The specification of function toupper has generated a garbled mix for assigns clause assigns clause \result.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accelio.c:82:[eva:garbled-mix] warning: The specification of function toupper has generated a garbled mix for assigns clause assigns clause \result.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:217:[eva:garbled-mix] warning: The specification of function strcpy has generated a garbled mix for assigns clause assigns clause *
+(dest + (0 .. strlen{Old}(src))).
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:220:[eva:garbled-mix] warning: The specification of function toupper has generated a garbled mix for assigns clause assigns clause \result.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:205:[eva:garbled-mix] warning: The specification of function printf_va_1 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:135:[eva:garbled-mix] warning: The specification of function printf_va_2 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:137:[eva:garbled-mix] warning: The specification of function printf_va_3 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:179:[eva:garbled-mix] warning: The specification of function printf_va_6 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:182:[eva:garbled-mix] warning: The specification of function printf_va_7 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:185:[eva:garbled-mix] warning: The specification of function printf_va_8 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:188:[eva:garbled-mix] warning: The specification of function printf_va_9 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:191:[eva:garbled-mix] warning: The specification of function printf_va_10 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:170:[eva:garbled-mix] warning: The specification of function printf_va_4 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:173:[eva:garbled-mix] warning: The specification of function printf_va_5 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:195:[eva:garbled-mix] warning: The specification of function printf_va_11 has generated a garbled mix for assigns clause assigns clause __fc_stdout->__fc_FILE_data.
+[eva:garbled-mix] warning: Garbled mix generated during analysis:
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:153}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:114}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:116}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:120}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:122}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:124}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:132}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:179}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:180}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:146}) }}
+{{ garbled mix of &{__malloc_w_cgc_set_cell_l153}
+ (origin: Misaligned
+ {/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:147}) }}
diff --git a/cgc-challenges/Accel/.frama-c/Accel.parse/framac.ast b/cgc-challenges/Accel/.frama-c/Accel.parse/framac.ast
new file mode 100644
index 0000000000000000000000000000000000000000..e0a0dfc83a121a9630ac6192bc6ba395becdbc71
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.parse/framac.ast
@@ -0,0 +1,3222 @@
+/* Generated by Frama-C */
+#include "ctype.h"
+#include "errno.h"
+#include "fcntl.h"
+#include "math.h"
+#include "signal.h"
+#include "stdarg.h"
+#include "stddef.h"
+#include "stdint.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "strings.h"
+#include "sys/mman.h"
+#include "sys/select.h"
+#include "sys/time.h"
+#include "sys/types.h"
+#include "unistd.h"
+struct cgc_aes_state {
+ uint8_t vec[16] __attribute__((__aligned__(1)));
+ uint8_t key[16] __attribute__((__aligned__(1)));
+ uint8_t datetime[16] __attribute__((__aligned__(1)));
+} __attribute__((__packed__, __aligned__(1)));
+typedef struct cgc_aes_state cgc_aes_state;
+struct cgc_prng {
+ cgc_aes_state state ;
+ uint8_t intermediate[16] ;
+ uint8_t random_data[16] ;
+ uint8_t random_idx ;
+};
+typedef struct cgc_prng cgc_prng_0;
+struct stack;
+typedef struct stack stack_t;
+struct stack {
+ char *data ;
+ stack_t *next ;
+};
+struct __anonstruct_operator_t_1 {
+ char const *name ;
+ double (*function)(stack_t **args, int *is_bad_formula) ;
+};
+typedef struct __anonstruct_operator_t_1 operator_t;
+struct queue;
+typedef struct queue queue_t;
+struct queue {
+ char *data ;
+ queue_t *next ;
+};
+enum __anonenum_cell_type_e_2 {
+ UNUSED = 0,
+ BAD_CELL = 1,
+ STRING = 2,
+ QUOTED_STRING = 3,
+ DOUBLE = 4,
+ FUNCTION = 5,
+ CELL_ID = 6,
+ FORMULA = 7
+};
+typedef enum __anonenum_cell_type_e_2 cell_type_e;
+struct cell {
+ unsigned int id ;
+ cell_type_e cell_type ;
+ char *str ;
+ char *formula ;
+};
+typedef struct cell cell_t;
+int receive_bytes_iPcz(char *buffer, size_t count);
+
+int __prng_state;
+/*@ assigns __prng_state;
+ assigns __prng_state \from seedValue; */
+void seed_prng(uint32_t seedValue);
+
+/*@ assigns \result, __prng_state;
+ assigns \result \from __prng_state;
+ assigns __prng_state \from __prng_state;
+ */
+uint32_t cgc_prng(void);
+
+ __attribute__((__noreturn__)) void cgc__terminate(unsigned int status);
+
+int cgc_transmit(int fd, void const *buf, size_t count, size_t *tx_bytes);
+
+int cgc_receive(int fd, void *buf, size_t count, size_t *rx_bytes);
+
+int cgc_fdwait(int nfds, fd_set *readfds, fd_set *writefds,
+ struct timeval const *timeout, int *readyfds);
+
+int cgc_allocate(size_t length, int is_executable, void **addr);
+
+int cgc_deallocate(void *addr, size_t length);
+
+int cgc_random(void *buf, size_t count, size_t *rnd_bytes);
+
+int receive_bytes_iPcz(char *buffer, size_t count)
+{
+ int __retres;
+ size_t total;
+ size_t rxbytes;
+ total = (unsigned int)0;
+ while (total < count) {
+ int tmp;
+ rxbytes = (unsigned int)0;
+ tmp = cgc_receive(0,(void *)(buffer + total),count - total,& rxbytes);
+ if (tmp == 0)
+ if (rxbytes == (size_t)0) {
+ __retres = 0;
+ goto return_label;
+ }
+ else total += rxbytes;
+ else {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_check_timeout(struct timeval const *timeout)
+{
+ int __retres;
+ if (! timeout) {
+ __retres = 0;
+ goto return_label;
+ }
+ else
+ if ((time_t)0 > timeout->tv_sec) goto _LOR;
+ else
+ if (0 > timeout->tv_usec) {
+ _LOR: {
+ __retres = 22;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+void cgc_init_prng(cgc_prng_0 *, cgc_aes_state const *);
+
+void cgc_aes_get_bytes(cgc_prng_0 *, uint32_t, uint8_t *);
+
+ __attribute__((__noreturn__)) void cgc__terminate(unsigned int status);
+void cgc__terminate(unsigned int status)
+{
+ exit((int)status);
+ return;
+}
+
+int cgc_transmit(int fd, void const *buf, size_t count, size_t *tx_bytes)
+{
+ int __retres;
+ ssize_t const ret = write(fd,buf,count);
+ if (ret < 0) {
+ __retres = __fc_errno;
+ goto return_label;
+ }
+ else
+ if (tx_bytes != (size_t *)0) *tx_bytes = (unsigned int)ret;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_receive(int fd, void *buf, size_t count, size_t *rx_bytes)
+{
+ int __retres;
+ ssize_t const ret = read(fd,buf,count);
+ if (ret < 0) {
+ __retres = __fc_errno;
+ goto return_label;
+ }
+ else
+ if (rx_bytes != (size_t *)0) *rx_bytes = (unsigned int)ret;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int cgc_copy_cgc_fd_set(fd_set const *cgc_fds, fd_set *os_fds,
+ int *num_fds)
+{
+ int __retres;
+ {
+ unsigned int fd = (unsigned int)0;
+ while (fd < (unsigned int)8 * sizeof(long)) {
+ {
+ int tmp;
+ tmp = FD_ISSET((int)fd,cgc_fds);
+ if (tmp) {
+ if (fd >= (unsigned int)(3 + 2 * 10)) {
+ __retres = 9;
+ goto return_label;
+ }
+ if (fd > (unsigned int)8 * sizeof(long)) goto __Cont;
+ FD_SET((int)fd,os_fds);
+ (*num_fds) ++;
+ }
+ }
+ __Cont: fd ++;
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static void cgc_copy_os_fd_set(fd_set const *os_fds, fd_set *cgc_fds)
+{
+ unsigned int fd = (unsigned int)0;
+ while (1) {
+ unsigned int tmp_0;
+ if ((unsigned int)8 * sizeof(long) < (unsigned int)8 * sizeof(long))
+ tmp_0 = (unsigned int)8 * sizeof(long);
+ else tmp_0 = (unsigned int)8 * sizeof(long);
+ ;
+ if (! (fd < tmp_0)) break;
+ {
+ int tmp;
+ tmp = FD_ISSET((int)fd,os_fds);
+ if (tmp) FD_SET((int)fd,cgc_fds);
+ }
+ fd ++;
+ }
+ return;
+}
+
+int cgc_fdwait(int nfds, fd_set *readfds, fd_set *writefds,
+ struct timeval const *timeout, int *readyfds)
+{
+ int __retres;
+ fd_set read_fds;
+ fd_set write_fds;
+ int tmp_3;
+ struct timeval *tmp_0;
+ fd_set *tmp_1;
+ fd_set *tmp_2;
+ int ret = cgc_check_timeout(timeout);
+ int actual_num_fds = 0;
+ struct timeval max_wait_time = {.tv_sec = (long)0, .tv_usec = 0};
+ if (ret) {
+ __retres = ret;
+ goto return_label;
+ }
+ else
+ if (0 > nfds) goto _LOR;
+ else
+ if ((unsigned int)8 * sizeof(long) < (unsigned int)nfds) {
+ _LOR: {
+ __retres = 22;
+ goto return_label;
+ }
+ }
+ FD_ZERO(& read_fds);
+ FD_ZERO(& write_fds);
+ if (readfds) {
+ ret = cgc_copy_cgc_fd_set((fd_set const *)readfds,& read_fds,
+ & actual_num_fds);
+ if (0 != ret) {
+ __retres = ret;
+ goto return_label;
+ }
+ }
+ if (writefds) {
+ ret = cgc_copy_cgc_fd_set((fd_set const *)writefds,& write_fds,
+ & actual_num_fds);
+ if (0 != ret) {
+ __retres = ret;
+ goto return_label;
+ }
+ }
+ if (actual_num_fds != nfds) {
+ __retres = 22;
+ goto return_label;
+ }
+ if (readfds) FD_ZERO(readfds);
+ if (writefds) FD_ZERO(writefds);
+ if (timeout) {
+ max_wait_time.tv_sec = timeout->tv_sec;
+ max_wait_time.tv_usec = timeout->tv_usec;
+ }
+ if (timeout) tmp_0 = & max_wait_time; else tmp_0 = (struct timeval *)0;
+ if (writefds) tmp_1 = & write_fds; else tmp_1 = (fd_set *)0;
+ if (readfds) tmp_2 = & read_fds; else tmp_2 = (fd_set *)0;
+ ;
+ tmp_3 = select(nfds,tmp_2,tmp_1,(fd_set *)0,tmp_0);
+ int num_selected_fds = tmp_3;
+ if (num_selected_fds < 0) {
+ __retres = __fc_errno;
+ goto return_label;
+ }
+ if (readfds) cgc_copy_os_fd_set((fd_set const *)(& read_fds),readfds);
+ if (writefds) cgc_copy_os_fd_set((fd_set const *)(& write_fds),writefds);
+ if (readyfds) *readyfds = num_selected_fds;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_allocate(size_t length, int is_executable, void **addr)
+{
+ int __retres;
+ int page_perms = 0x1 | 0x2;
+ if (is_executable) page_perms |= 0x4;
+ void *return_address =
+ mmap((void *)0,length,page_perms,0x20 | 0x02,-1,(long)0);
+ if (return_address == (void *)(-1)) {
+ __retres = __fc_errno;
+ goto return_label;
+ }
+ if (addr) *addr = return_address;
+ memset(return_address,0,length);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_deallocate(void *addr, size_t length)
+{
+ int __retres;
+ int const ret = munmap(addr,length);
+ if (ret < 0) {
+ __retres = __fc_errno;
+ goto return_label;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static cgc_prng_0 *cgc_internal_prng = (cgc_prng_0 *)0;
+/*@ requires valid_read_string(s);
+ requires valid_read_string(format);
+ requires \valid(param0);
+ ensures \initialized(param0);
+ assigns \result, *param0;
+ assigns \result
+ \from (indirect: *(s + (0 ..))), (indirect: *(format + (0 ..)));
+ assigns *param0
+ \from (indirect: *(s + (0 ..))), (indirect: *(format + (0 ..)));
+ */
+int sscanf_va_1(char const * __restrict s, char const * __restrict format,
+ unsigned char *param0);
+
+static void cgc_try_init_prng(void)
+{
+ if (cgc_internal_prng != (cgc_prng_0 *)0) goto return_label;
+ uint8_t prng_seed[16 * 3] =
+ {(unsigned char)0x73,
+ (unsigned char)0x65,
+ (unsigned char)0x65,
+ (unsigned char)0x64,
+ (unsigned char)0x73,
+ (unsigned char)0x65,
+ (unsigned char)0x65,
+ (unsigned char)0x64,
+ (unsigned char)0x73,
+ (unsigned char)0x65,
+ (unsigned char)0x65,
+ (unsigned char)0x64,
+ (unsigned char)0x73,
+ (unsigned char)0x65,
+ (unsigned char)0x65,
+ (unsigned char)0x64,
+ (unsigned char)0x30,
+ (unsigned char)0x31,
+ (unsigned char)0x32,
+ (unsigned char)0x33,
+ (unsigned char)0x34,
+ (unsigned char)0x35,
+ (unsigned char)0x36,
+ (unsigned char)0x37,
+ (unsigned char)0x38,
+ (unsigned char)0x39,
+ (unsigned char)0x61,
+ (unsigned char)0x62,
+ (unsigned char)0x63,
+ (unsigned char)0x64,
+ (unsigned char)0x65,
+ (unsigned char)0x66,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00,
+ (unsigned char)0x00};
+ char const *prng_seed_hex = getenv("seed");
+ if (prng_seed_hex != (char const *)0) {
+ size_t tmp_0;
+ tmp_0 = strlen(prng_seed_hex);
+ if (tmp_0 == (size_t)((16 * 3) * 2)) {
+ char const *pos = prng_seed_hex;
+ {
+ int i = 0;
+ while (i < 16 * 3) {
+ sscanf_va_1(pos,"%2hhx",(unsigned char *)(& prng_seed[i]));
+ pos += 2;
+ i ++;
+ }
+ }
+ }
+ }
+ cgc_internal_prng = (cgc_prng_0 *)malloc(sizeof(cgc_prng_0));
+ cgc_aes_state *seed = (cgc_aes_state *)(prng_seed);
+ cgc_init_prng(cgc_internal_prng,(cgc_aes_state const *)seed);
+ return_label: return;
+}
+
+int cgc_random(void *buf, size_t count, size_t *rnd_bytes)
+{
+ int __retres;
+ cgc_try_init_prng();
+ cgc_aes_get_bytes(cgc_internal_prng,count,(uint8_t *)buf);
+ if (rnd_bytes) *rnd_bytes = count;
+ __retres = 0;
+ return __retres;
+}
+
+/*@ assigns \nothing; */
+static void cgc_initialize_flag_page(void) __attribute__((__constructor__));
+
+int cgc_init_sheet(void);
+
+char *cgc_show_cell(char *cell_id, int is_repr, char *val_str, size_t size);
+
+int cgc_set_cell(char *cell_id, char *cell_str, size_t size);
+
+int cgc_clear_cell(char *cell_id);
+
+void cgc_print_assigned_cells(void);
+
+int cgc_strtrim(char *str, size_t size, int sides);
+
+int cgc_valid_cell_id(char *input);
+
+int cgc_get_rowcol(char *input, char *row, char *col, char delim);
+
+int cgc_sanitize_formula(char *formula, size_t size);
+
+char *cgc_peek_top(stack_t *stack);
+
+int cgc_push(stack_t **stack, char *data);
+
+int cgc_push_copy(stack_t **stack, char *data, size_t size);
+
+char *cgc_pop_copy(stack_t **stack);
+
+void cgc_clear_stack(stack_t **stack);
+
+double cgc_handle_op_avg(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_count(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_max(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_median(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_min(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_stddev(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_abs(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_add(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_cos(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_ln(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_log10(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_power(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_product(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_quotient(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_sin(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_sqrt(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_subtract(stack_t **args, int *is_bad_formula);
+
+double cgc_handle_op_sum(stack_t **args, int *is_bad_formula);
+
+char *cgc_peek_front(queue_t *queue);
+
+int cgc_enqueue(queue_t **queue, char *data);
+
+int cgc_enqueue_copy(queue_t **queue, char *data, size_t size);
+
+char *cgc_dequeue_copy(queue_t **queue);
+
+void cgc_clear_queue(queue_t **queue);
+
+char *cgc_itoa(int value, char *str, size_t size);
+
+char *cgc_ftoa(double value, char *str, size_t size);
+
+double cgc_atof(char *str, size_t size, int *bad_conversion);
+
+static operator_t *cgc_get_op(char *name);
+
+static cell_type_e cgc_parsearg(char *arg);
+
+static int cgc_is_arg_arithmetic(char *arg);
+
+static cell_t *cgc_get_cell(char *cell_id);
+
+static queue_t *cgc_infixtorpn(char *infix, size_t size);
+
+static double cgc_eval_formula(char *formula, int *is_bad_formula,
+ stack_t **cir_ref, int id);
+
+static cell_t *_g_sheet = (cell_t *)0;
+static cell_t **g_sheet = (cell_t **)0;
+static operator_t operators[19] =
+ {{.name = "AVG", .function = & cgc_handle_op_avg},
+ {.name = "COUNT", .function = & cgc_handle_op_count},
+ {.name = "MAX", .function = & cgc_handle_op_max},
+ {.name = "MEDIAN", .function = & cgc_handle_op_median},
+ {.name = "MIN", .function = & cgc_handle_op_min},
+ {.name = "STDDEV", .function = & cgc_handle_op_stddev},
+ {.name = "ABS", .function = & cgc_handle_op_abs},
+ {.name = "+", .function = & cgc_handle_op_add},
+ {.name = "COS", .function = & cgc_handle_op_cos},
+ {.name = "LN", .function = & cgc_handle_op_ln},
+ {.name = "LOG10", .function = & cgc_handle_op_log10},
+ {.name = "POWER", .function = & cgc_handle_op_power},
+ {.name = "*", .function = & cgc_handle_op_product},
+ {.name = "/", .function = & cgc_handle_op_quotient},
+ {.name = "SIN", .function = & cgc_handle_op_sin},
+ {.name = "SQRT", .function = & cgc_handle_op_sqrt},
+ {.name = "-", .function = & cgc_handle_op_subtract},
+ {.name = "SUM", .function = & cgc_handle_op_sum},
+ {.name = (char const *)0,
+ .function = (double (*)(stack_t **args, int *is_bad_formula))0}};
+int cgc_init_sheet(void)
+{
+ int __retres;
+ size_t i;
+ size_t j;
+ unsigned int id = (unsigned int)0;
+ _g_sheet = (cell_t *)calloc((unsigned int)((26 * 27) * 100),sizeof(cell_t));
+ if (_g_sheet == (cell_t *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ g_sheet = (cell_t **)malloc((unsigned int)(26 * 27) * sizeof(cell_t *));
+ if (g_sheet == (cell_t **)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ i = (unsigned int)0;
+ while (i < (size_t)(26 * 27)) {
+ *(g_sheet + i) = _g_sheet + i * (size_t)100;
+ i += (size_t)1;
+ }
+ i = (unsigned int)0;
+ while (i < (size_t)(26 * 27)) {
+ j = (unsigned int)0;
+ while (j < (size_t)100) {
+ unsigned int tmp;
+ tmp = id;
+ id ++;
+ (*(g_sheet + i) + j)->id = tmp;
+ j += (size_t)1;
+ }
+ i += (size_t)1;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+char *cgc_show_cell(char *cell_id, int is_repr, char *val_str, size_t size)
+{
+ char *__retres;
+ int is_bad_formula;
+ double val = 0.0;
+ cell_t *cell = cgc_get_cell(cell_id);
+ if (cell == (cell_t *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ if (cell->cell_type == (unsigned int)UNUSED) {
+ __retres = (char *)"";
+ goto return_label;
+ }
+ if (cell->cell_type == (unsigned int)BAD_CELL) {
+ __retres = (char *)"!VALUE";
+ goto return_label;
+ }
+ if (is_repr) {
+ __retres = cell->str;
+ goto return_label;
+ }
+ if (cell->formula != (char *)0) {
+ stack_t *cir_ref = (stack_t *)0;
+ val = cgc_eval_formula(cell->formula,& is_bad_formula,& cir_ref,
+ (int)cell->id);
+ if (is_bad_formula) {
+ __retres = (char *)"!FORMULA: CIRREF/STR/DIV0";
+ goto return_label;
+ }
+ cgc_ftoa(val,val_str,size);
+ __retres = val_str;
+ goto return_label;
+ }
+ else {
+ __retres = cell->str;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+int cgc_set_cell(char *cell_id, char *cell_str, size_t size)
+{
+ int __retres;
+ size_t tmp_2;
+ size_t tmp_3;
+ if (cell_str == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ else {
+ size_t tmp;
+ tmp = strlen((char const *)cell_str);
+ if (tmp == (size_t)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ else {
+ size_t tmp_0;
+ tmp_0 = strlen((char const *)cell_str);
+ ;
+ if (tmp_0 >= size) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ }
+ cell_t *cell = cgc_get_cell(cell_id);
+ if (cell == (cell_t *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (cell->cell_type != (unsigned int)UNUSED) {
+ free((void *)cell->str);
+ cell->str = (char *)0;
+ cell->cell_type = UNUSED;
+ cell->formula = (char *)0;
+ }
+ tmp_2 = strlen((char const *)cell_str);
+ cell->str = (char *)malloc(tmp_2 + (size_t)1);
+ if (cell->str == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ strcpy(cell->str,(char const *)cell_str);
+ tmp_3 = strlen((char const *)cell_str);
+ if (tmp_3 >= (size_t)2) {
+ if ((int)*(cell_str + 0) == '=') {
+ cell->formula = cell->str + 1;
+ cell->cell_type = FORMULA;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ cell->cell_type = cgc_parsearg(cell->str);
+ if (cell->cell_type != (unsigned int)DOUBLE) cell->cell_type = STRING;
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_clear_cell(char *cell_id)
+{
+ int __retres;
+ cell_t *cell = cgc_get_cell(cell_id);
+ if (cell == (cell_t *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (cell->cell_type != (unsigned int)UNUSED) {
+ free((void *)cell->str);
+ cell->str = (char *)0;
+ cell->cell_type = UNUSED;
+ cell->formula = (char *)0;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param2);
+ requires valid_read_string(param1);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param2 + (0 ..))),
+ (indirect: *(param1 + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param2 + (0 ..)), *(param1 + (0 ..)), *(param0 + (0 ..));
+ */
+int printf_va_1(char const * __restrict format, char *param0, char *param1,
+ char *param2);
+
+void cgc_print_assigned_cells(void)
+{
+ char row_id[3];
+ char col_id[4];
+ size_t i;
+ size_t j;
+ unsigned int id;
+ cell_t *cell;
+ i = (unsigned int)0;
+ while (i < (size_t)(26 * 27)) {
+ j = (unsigned int)0;
+ while (j < (size_t)100) {
+ cell = *(g_sheet + i) + j;
+ if (cell->cell_type != (unsigned int)UNUSED) {
+ id = cell->id;
+ cgc_itoa((int)(id % (unsigned int)100),col_id,sizeof(col_id));
+ row_id[2] = (char)'\000';
+ if (id / (unsigned int)(100 * 26) == (unsigned int)0) row_id[1] = (char)'\000';
+ else row_id[1] = (char)((id / (unsigned int)100) % (unsigned int)26 + (unsigned int)'A');
+ if (id / (unsigned int)(100 * 26) == (unsigned int)0) row_id[0] = (char)(
+ (id / (unsigned int)100) % (unsigned int)26 + (unsigned int)'A');
+ else row_id[0] = (char)((id / (unsigned int)(100 * 26) - (unsigned int)1) % (unsigned int)26 + (unsigned int)'A');
+ printf_va_1("%s%s=%s\n",row_id,col_id,cell->str);
+ }
+ j += (size_t)1;
+ }
+ i += (size_t)1;
+ }
+ return;
+}
+
+static operator_t *cgc_get_op(char *name)
+{
+ operator_t *__retres;
+ char *tmp_0;
+ size_t tmp;
+ size_t i;
+ if (name == (char *)0) {
+ __retres = (operator_t *)0;
+ goto return_label;
+ }
+ tmp = strlen((char const *)name);
+ tmp_0 = (char *)malloc(tmp + (size_t)1);
+ char *upper_name = tmp_0;
+ strcpy(upper_name,(char const *)name);
+ size_t len = strlen((char const *)upper_name);
+ i = (unsigned int)0;
+ while (i < len) {
+ int tmp_2;
+ tmp_2 = toupper((int)*(upper_name + i));
+ *(upper_name + i) = (char)tmp_2;
+ i += (size_t)1;
+ }
+ operator_t *op = (operator_t *)0;
+ op = operators;
+ while (op->name != (char const *)0) {
+ {
+ int tmp_3;
+ tmp_3 = strcmp(op->name,(char const *)upper_name);
+ if (tmp_3 == 0) break;
+ }
+ op ++;
+ }
+ free((void *)upper_name);
+ if (op->name == (char const *)0) {
+ __retres = (operator_t *)0;
+ goto return_label;
+ }
+ else {
+ __retres = op;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static cell_type_e cgc_parsearg(char *arg)
+{
+ cell_type_e __retres;
+ if (arg == (char *)0) {
+ __retres = BAD_CELL;
+ goto return_label;
+ }
+ int is_double = 0;
+ int has_period = 0;
+ int has_negative = 0;
+ int is_hard_string = 0;
+ int is_soft_string = 0;
+ char *beg_arg = arg;
+ while ((int)*arg != '\000') {
+ if ((int)*arg >= '0') {
+ if ((int)*arg <= '9') is_double ++; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)*arg == '-') {
+ is_double ++;
+ has_negative ++;
+ }
+ else
+ if ((int)*arg == '.') {
+ is_double ++;
+ has_period ++;
+ }
+ else
+ if ((int)*arg == '\"') is_hard_string ++; else is_soft_string ++;
+ }
+ arg ++;
+ }
+ arg = beg_arg;
+ if (is_hard_string)
+ if (is_hard_string == 2) {
+ arg --;
+ ;
+ if ((int)*arg == '\"') {
+ __retres = QUOTED_STRING;
+ goto return_label;
+ }
+ else {
+ __retres = STRING;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = STRING;
+ goto return_label;
+ }
+ else
+ if (is_soft_string) {
+ int tmp;
+ operator_t *tmp_0;
+ if (has_period > 1) {
+ __retres = STRING;
+ goto return_label;
+ }
+ else
+ if (has_negative > 1) {
+ __retres = STRING;
+ goto return_label;
+ }
+ tmp = cgc_valid_cell_id(arg);
+ if (tmp == 0) {
+ __retres = CELL_ID;
+ goto return_label;
+ }
+ tmp_0 = cgc_get_op(arg);
+ if (tmp_0 != (operator_t *)0) {
+ __retres = FUNCTION;
+ goto return_label;
+ }
+ __retres = STRING;
+ goto return_label;
+ }
+ else
+ if (is_double) {
+ if (has_period > 1) {
+ __retres = STRING;
+ goto return_label;
+ }
+ else
+ if (has_negative > 1) {
+ __retres = STRING;
+ goto return_label;
+ }
+ if (has_period) {
+ if (is_double == 1) {
+ __retres = STRING;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (has_period)
+ if (has_negative)
+ if (is_double == 2) {
+ __retres = STRING;
+ goto return_label;
+ }
+ }
+ if (has_negative)
+ if (is_double == 1) {
+ __retres = FUNCTION;
+ goto return_label;
+ }
+ __retres = DOUBLE;
+ goto return_label;
+ }
+ else {
+ __retres = BAD_CELL;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int cgc_is_arg_arithmetic(char *arg)
+{
+ int tmp_3;
+ int tmp;
+ tmp = memcmp((void const *)arg,(void const *)"+",(unsigned int)2);
+ if (tmp == 0) tmp_3 = 1;
+ else {
+ int tmp_0;
+ tmp_0 = memcmp((void const *)arg,(void const *)"-",(unsigned int)2);
+ if (tmp_0 == 0) tmp_3 = 1;
+ else {
+ int tmp_1;
+ tmp_1 = memcmp((void const *)arg,(void const *)"/",(unsigned int)2);
+ if (tmp_1 == 0) tmp_3 = 1;
+ else {
+ int tmp_2;
+ tmp_2 = memcmp((void const *)arg,(void const *)"*",(unsigned int)2);
+ if (tmp_2 == 0) tmp_3 = 1; else tmp_3 = 0;
+ }
+ }
+ }
+ return tmp_3;
+}
+
+static cell_t *cgc_get_cell(char *cell_id)
+{
+ cell_t *__retres;
+ char row_str[3];
+ char col_str[3];
+ int i;
+ int len;
+ int tmp;
+ size_t tmp_0;
+ int row_idx = 0;
+ int col_idx = 0;
+ tmp = cgc_get_rowcol(cell_id,row_str,col_str,(char)'\000');
+ if (tmp == -1) {
+ __retres = (cell_t *)0;
+ goto return_label;
+ }
+ tmp_0 = strlen((char const *)(row_str));
+ len = (int)tmp_0;
+ i = 0;
+ while (i < len) {
+ double tmp_1;
+ tmp_1 = pow((double)26,(double)((len - i) - 1));
+ row_idx = (int)((double)row_idx + (double)((int)row_str[i] - 64) * tmp_1);
+ i ++;
+ }
+ row_idx --;
+ col_idx = (int)strtol((char const *)(col_str),(char **)0,10);
+ __retres = *(g_sheet + row_idx) + col_idx;
+ return_label: return __retres;
+}
+
+static int cgc_eval_function(operator_t *op, stack_t **values, char *val_str,
+ size_t size)
+{
+ int __retres;
+ char *arg;
+ size_t i;
+ operator_t *nested_op;
+ int tmp_1;
+ char *tmp_5;
+ if (op == (operator_t *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (val_str == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (size <= (size_t)2) {
+ __retres = -1;
+ goto return_label;
+ }
+ double val = 0.0;
+ char *op_name = (char *)op->name;
+ size_t num_args = (unsigned int)0;
+ int is_bad_formula = 0;
+ stack_t *args = (stack_t *)0;
+ tmp_1 = cgc_is_arg_arithmetic(op_name);
+ if (tmp_1) num_args = (unsigned int)2;
+ else {
+ long tmp_0;
+ char *arg_count = cgc_pop_copy(values);
+ if (arg_count == (char *)0) goto error;
+ tmp_0 = strtol((char const *)arg_count,(char **)0,10);
+ num_args = (unsigned int)tmp_0;
+ free((void *)arg_count);
+ }
+ i = (unsigned int)0;
+ while (i < num_args) {
+ {
+ cell_type_e tmp_4;
+ arg = cgc_pop_copy(values);
+ tmp_4 = cgc_parsearg(arg);
+ if (tmp_4 == (unsigned int)FUNCTION) {
+ int tmp_2;
+ nested_op = cgc_get_op(arg);
+ free((void *)arg);
+ tmp_2 = cgc_eval_function(nested_op,values,val_str,size);
+ if (tmp_2 == 0) cgc_push_copy(& args,val_str,size); else goto error;
+ }
+ else {
+ int tmp_3;
+ tmp_3 = cgc_push(& args,arg);
+ if (tmp_3 != 0) goto error;
+ }
+ }
+ i += (size_t)1;
+ }
+ val = (*(op->function))(& args,& is_bad_formula);
+ if (is_bad_formula) goto error;
+ tmp_5 = cgc_ftoa(val,val_str,size);
+ if (tmp_5 == (char *)0) goto error;
+ __retres = 0;
+ goto return_label;
+ error: cgc_clear_stack(& args);
+ __retres = -1;
+ return_label: return __retres;
+}
+
+/*@ ensures \initialized(\old(is_bad_formula));
+ assigns \result, *is_bad_formula;
+ assigns \result \from \nothing;
+ assigns *is_bad_formula \from \nothing;
+ */
+static double cgc_eval_formula(char *formula, int *is_bad_formula,
+ stack_t **cir_ref, int id)
+{
+ char val_str[512];
+ char tmp_id_str[512];
+ cell_type_e cell_type;
+ char *arg;
+ char *tmp;
+ size_t tmp_0;
+ queue_t *tmp_2;
+ size_t tmp_1;
+ char *tmp_11;
+ size_t size = (unsigned int)512;
+ double val = 0.0;
+ double result = 0.0;
+ *is_bad_formula = 0;
+ tmp = cgc_itoa(id,tmp_id_str,size);
+ if (tmp == (char *)0) goto error;
+ tmp_0 = strlen((char const *)(tmp_id_str));
+ ;
+ cgc_push_copy(cir_ref,tmp_id_str,tmp_0 + (size_t)1);
+ tmp_1 = strlen((char const *)formula);
+ ;
+ tmp_2 = cgc_infixtorpn(formula,tmp_1 + (size_t)1);
+ queue_t *rpn = tmp_2;
+ queue_t *args = (queue_t *)0;
+ stack_t *values = (stack_t *)0;
+ stack_t *tmp_3 = (stack_t *)0;
+ operator_t *op = (operator_t *)0;
+ while (rpn != (queue_t *)0) {
+ arg = cgc_dequeue_copy(& rpn);
+ cell_type = cgc_parsearg(arg);
+ switch (cell_type) {
+ int tmp_4;
+ case (cell_type_e)DOUBLE: cgc_push(& values,arg);
+ break;
+ case (cell_type_e)FUNCTION: op = cgc_get_op(arg);
+ tmp_4 = cgc_eval_function(op,& values,val_str,size);
+ if (tmp_4 == -1) goto error;
+ cgc_push_copy(& values,val_str,size);
+ break;
+ case (cell_type_e)CELL_ID: tmp_3 = *cir_ref;
+ cell_t *cell = cgc_get_cell(arg);
+ if (cell == (cell_t *)0) goto error;
+ while (tmp_3 != (stack_t *)0) {
+ char *tmp_6;
+ int tmp_8;
+ size_t tmp_7;
+ tmp_6 = cgc_itoa((int)cell->id,tmp_id_str,size);
+ if (tmp_6 == (char *)0) goto error;
+ tmp_7 = strlen((char const *)tmp_3->data);
+ ;
+ tmp_8 = memcmp((void const *)tmp_3->data,(void const *)(tmp_id_str),
+ tmp_7 + (size_t)1);
+ if (tmp_8 == 0) goto error;
+ tmp_3 = tmp_3->next;
+ }
+ if (cell->cell_type == (unsigned int)UNUSED) cgc_push_copy(& values,
+ (char *)"0",
+ sizeof("0"));
+ else
+ if (cell->cell_type == (unsigned int)DOUBLE) {
+ size_t tmp_9;
+ tmp_9 = strlen((char const *)cell->str);
+ ;
+ cgc_push_copy(& values,cell->str,tmp_9 + (size_t)1);
+ }
+ else
+ if (cell->cell_type == (unsigned int)FORMULA) {
+ val = cgc_eval_formula(cell->formula,is_bad_formula,cir_ref,
+ (int)cell->id);
+ if (*is_bad_formula) goto error;
+ cgc_ftoa(val,val_str,size);
+ cgc_push_copy(& values,val_str,size);
+ }
+ else goto error;
+ break;
+ default: goto error;
+ }
+ }
+ char *result_str = cgc_pop_copy(& values);
+ if (values != (stack_t *)0) goto error;
+ result = cgc_atof(result_str,size,is_bad_formula);
+ if (*is_bad_formula) goto error;
+ goto cleanup;
+ error: *is_bad_formula = 1;
+ val = 0.0;
+ cgc_clear_queue(& rpn);
+ cgc_clear_queue(& args);
+ cgc_clear_stack(& values);
+ cleanup: tmp_11 = cgc_pop_copy(cir_ref);
+ free((void *)tmp_11);
+ return result;
+}
+
+static queue_t *cgc_infixtorpn(char *infix, size_t size)
+{
+ char *arg;
+ char *iter;
+ char delim;
+ char *value;
+ cell_type_e arg_type;
+ int tmp_1;
+ int is_mismatched = 0;
+ int func_size = 16;
+ int func_idx = -1;
+ char *formula = malloc(size);
+ int *func_args = malloc((unsigned int)func_size * sizeof(int));
+ char *delims = (char *)"():,+-*/";
+ char arith_op[2] = {(char)'\000', (char)'\000'};
+ stack_t *operators_0 = (stack_t *)0;
+ queue_t *output_q = (queue_t *)0;
+ memcpy((void *)formula,(void const *)infix,size);
+ tmp_1 = cgc_sanitize_formula(formula,size);
+ if (tmp_1 != 0) goto cleanup;
+ iter = formula;
+ arg = iter;
+ size_t i = (unsigned int)0;
+ char prev_char = (char)0;
+ while (1) {
+ size_t tmp_38;
+ tmp_38 = i;
+ i += (size_t)1;
+ ;
+ if (! (tmp_38 < size)) break;
+ {
+ char *tmp_3;
+ tmp_3 = strchr((char const *)delims,(int)*iter);
+ if (tmp_3 == (char *)0) {
+ if ((int)*iter != '\000') {
+ prev_char = *iter;
+ iter ++;
+ continue;
+ }
+ else goto _LAND;
+ }
+ else {
+ char *tmp_2;
+ _LAND: tmp_2 = strchr((char const *)delims,(int)*iter);
+ if (tmp_2 != (char *)0)
+ if ((int)*iter == '-')
+ if (i <= (size_t)1) goto _LOR_0;
+ else
+ if ((int)prev_char != ')')
+ if ((int)prev_char < '0') goto _LOR_0;
+ else
+ if ((int)prev_char > '9') {
+ _LOR_0: {
+ prev_char = *iter;
+ iter ++;
+ continue;
+ }
+ }
+ }
+ prev_char = *iter;
+ delim = *iter;
+ *iter = (char)'\000';
+ arg_type = cgc_parsearg(arg);
+ switch (arg_type) {
+ size_t tmp_4;
+ size_t tmp_6;
+ case (cell_type_e)DOUBLE: case (cell_type_e)CELL_ID:
+ { /* sequence */
+ tmp_4 = strlen((char const *)arg);
+ ;
+ }
+ cgc_enqueue_copy(& output_q,arg,tmp_4 + (size_t)1);
+ break;
+ case (cell_type_e)FUNCTION: ;
+ if (func_idx == func_size - 1) {
+ func_size *= 2;
+ int *temp =
+ realloc((void *)func_args,(unsigned int)func_size * sizeof(int));
+ if (temp == (int *)0) goto error;
+ func_args = temp;
+ }
+ func_idx ++;
+ *(func_args + func_idx) = 0;
+ tmp_6 = strlen((char const *)arg);
+ ;
+ cgc_push_copy(& operators_0,arg,tmp_6 + (size_t)1);
+ break;
+ case (cell_type_e)BAD_CELL: break;
+ default: goto error;
+ }
+ is_mismatched = 0;
+ switch ((int)delim) {
+ size_t tmp_7;
+ char *tmp_11;
+ char num_args_str[16];
+ char *tmp_18;
+ char *tmp_17;
+ size_t tmp_31;
+ size_t tmp_37;
+ case '(': tmp_7 = strlen("(");
+ cgc_push_copy(& operators_0,(char *)"(",tmp_7 + (size_t)1);
+ break;
+ case ')': is_mismatched = 1;
+ while (operators_0 != (stack_t *)0) {
+ int tmp_10;
+ char *tmp_9;
+ tmp_9 = cgc_peek_top(operators_0);
+ tmp_10 = strcmp((char const *)tmp_9,"(");
+ if (tmp_10 == 0) {
+ value = cgc_pop_copy(& operators_0);
+ free((void *)value);
+ is_mismatched = 0;
+ break;
+ }
+ else {
+ char *tmp_8;
+ tmp_8 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_8);
+ }
+ }
+ tmp_11 = cgc_peek_top(operators_0);
+ if (tmp_11 == (char *)0) break;
+ else
+ if (func_idx < 0) break;
+ tmp_17 = cgc_peek_top(operators_0);
+ ;
+ tmp_18 = strchr((char const *)delims,(int)*(tmp_17 + 0));
+ if (tmp_18 != (char *)0) break;
+ else {
+ cell_type_e tmp_16;
+ char *tmp_15;
+ tmp_15 = cgc_peek_top(operators_0);
+ tmp_16 = cgc_parsearg(tmp_15);
+ if (tmp_16 == (unsigned int)FUNCTION) {
+ char *tmp_13;
+ int tmp_12;
+ char *tmp_14;
+ tmp_12 = func_idx;
+ func_idx --;
+ ;
+ tmp_13 = cgc_itoa(*(func_args + tmp_12) + 1,num_args_str,
+ sizeof(num_args_str));
+ cgc_enqueue_copy(& output_q,tmp_13,sizeof(num_args_str));
+ tmp_14 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_14);
+ }
+ }
+ break;
+ case ',': is_mismatched = 1;
+ while (operators_0 != (stack_t *)0) {
+ int tmp_21;
+ char *tmp_20;
+ tmp_20 = cgc_peek_top(operators_0);
+ tmp_21 = strcmp((char const *)tmp_20,"(");
+ if (tmp_21 == 0) {
+ if (func_idx >= 0) (*(func_args + func_idx)) ++;
+ is_mismatched = 0;
+ break;
+ }
+ else {
+ char *tmp_19;
+ tmp_19 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_19);
+ }
+ }
+ break;
+ case '+': case '-': arith_op[0] = delim;
+ while (operators_0 != (stack_t *)0) {
+ int tmp_24;
+ char *tmp_23;
+ tmp_23 = cgc_peek_top(operators_0);
+ tmp_24 = strcmp((char const *)tmp_23,"-");
+ if (tmp_24 == 0) goto _LOR_1;
+ else {
+ int tmp_26;
+ char *tmp_25;
+ tmp_25 = cgc_peek_top(operators_0);
+ tmp_26 = strcmp((char const *)tmp_25,"+");
+ if (tmp_26 == 0) goto _LOR_1;
+ else {
+ int tmp_28;
+ char *tmp_27;
+ tmp_27 = cgc_peek_top(operators_0);
+ tmp_28 = strcmp((char const *)tmp_27,"+");
+ if (tmp_28 == 0) goto _LOR_1;
+ else {
+ int tmp_30;
+ char *tmp_29;
+ tmp_29 = cgc_peek_top(operators_0);
+ tmp_30 = strcmp((char const *)tmp_29,"/");
+ if (tmp_30 == 0) {
+ char *tmp_22;
+ _LOR_1: tmp_22 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_22);
+ }
+ else break;
+ }
+ }
+ }
+ }
+ tmp_31 = strlen((char const *)(arith_op));
+ cgc_push_copy(& operators_0,arith_op,tmp_31 + (size_t)1);
+ break;
+ case '*': case '/': arith_op[0] = delim;
+ while (operators_0 != (stack_t *)0) {
+ int tmp_34;
+ char *tmp_33;
+ tmp_33 = cgc_peek_top(operators_0);
+ tmp_34 = strcmp((char const *)tmp_33,"/");
+ if (tmp_34 == 0) goto _LOR_2;
+ else {
+ int tmp_36;
+ char *tmp_35;
+ tmp_35 = cgc_peek_top(operators_0);
+ tmp_36 = strcmp((char const *)tmp_35,"*");
+ if (tmp_36 == 0) {
+ char *tmp_32;
+ _LOR_2: tmp_32 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_32);
+ }
+ else break;
+ }
+ }
+ tmp_37 = strlen((char const *)(arith_op));
+ cgc_push_copy(& operators_0,arith_op,tmp_37 + (size_t)1);
+ break;
+ case '\000': goto finish;
+ default: goto error;
+ }
+ if (is_mismatched) goto error;
+ iter ++;
+ arg = iter;
+ }
+ }
+ finish:
+ while (operators_0 != (stack_t *)0) {
+ int tmp_40;
+ char *tmp_39;
+ char *tmp_43;
+ tmp_39 = cgc_peek_top(operators_0);
+ tmp_40 = strcmp((char const *)tmp_39,"(");
+ if (tmp_40 == 0) goto error;
+ else {
+ int tmp_42;
+ char *tmp_41;
+ tmp_41 = cgc_peek_top(operators_0);
+ tmp_42 = strcmp((char const *)tmp_41,")");
+ if (tmp_42 == 0) goto error;
+ }
+ tmp_43 = cgc_pop_copy(& operators_0);
+ cgc_enqueue(& output_q,tmp_43);
+ }
+ goto cleanup;
+ error: cgc_clear_queue(& output_q);
+ cgc_clear_stack(& operators_0);
+ cleanup: free((void *)formula);
+ free((void *)func_args);
+ return output_q;
+}
+
+double cgc_handle_op_avg(stack_t **args, int *is_bad_formula)
+{
+ double __retres;
+ double operand;
+ size_t i = (unsigned int)0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ char *front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ result += operand;
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ __retres = result / (double)i;
+ return __retres;
+}
+
+double cgc_handle_op_count(stack_t **args, int *is_bad_formula)
+{
+ double operand;
+ size_t i = (unsigned int)0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ char *front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ result = (double)i;
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ return result;
+}
+
+double cgc_handle_op_max(stack_t **args, int *is_bad_formula)
+{
+ double operand;
+ size_t i = (unsigned int)0;
+ double max = 0.0;
+ if (*args == (stack_t *)0) goto error;
+ char *front = cgc_pop_copy(args);
+ if (front != (char *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ max = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ i += (size_t)1;
+ }
+ front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_1;
+ ;
+ tmp_1 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_1 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (operand > max) max = operand;
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ max = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ return max;
+}
+
+double cgc_handle_op_median(stack_t **args, int *is_bad_formula)
+{
+ stack_t *sorted;
+ stack_t *tmp;
+ stack_t *prev;
+ double operand;
+ double temp;
+ size_t tmp_1;
+ size_t i = (unsigned int)0;
+ sorted = (stack_t *)0;
+ if (*args == (stack_t *)0) goto error;
+ sorted = (stack_t *)0;
+ double median = 0.0;
+ char *front = cgc_pop_copy(args);
+ ;
+ tmp_1 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_1 + (size_t)1,is_bad_formula);
+ if (*is_bad_formula) {
+ free((void *)front);
+ goto error;
+ }
+ else {
+ cgc_push(& sorted,front);
+ i += (size_t)1;
+ }
+ front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_2;
+ ;
+ tmp_2 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_2 + (size_t)1,is_bad_formula);
+ if (*is_bad_formula) goto error;
+ tmp = sorted;
+ int passed_first = 0;
+ int is_inserted = 0;
+ stack_t *elem = (stack_t *)0;
+ while (tmp != (stack_t *)0) {
+ size_t tmp_3;
+ ;
+ tmp_3 = strlen((char const *)tmp->data);
+ ;
+ temp = cgc_atof(tmp->data,tmp_3 + (size_t)1,is_bad_formula);
+ if (operand <= temp) {
+ if (! passed_first) cgc_push(& sorted,front);
+ else {
+ elem = (stack_t *)malloc(sizeof(stack_t));
+ elem->data = front;
+ elem->next = tmp;
+ prev->next = elem;
+ }
+ is_inserted = 1;
+ break;
+ }
+ else {
+ prev = tmp;
+ tmp = tmp->next;
+ passed_first ++;
+ }
+ }
+ if (! is_inserted) {
+ tmp = sorted;
+ while (tmp->next != (stack_t *)0) tmp = tmp->next;
+ elem = (stack_t *)malloc(sizeof(stack_t));
+ elem->data = front;
+ elem->next = (stack_t *)0;
+ tmp->next = elem;
+ }
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ tmp = sorted;
+ int j = 0;
+ if (i % (unsigned int)2 == (unsigned int)0) {
+ double tmp_5;
+ size_t tmp_4;
+ double tmp_7;
+ size_t tmp_6;
+ j = 0;
+ while ((size_t)j < i / (size_t)2 - (size_t)1) {
+ tmp = tmp->next;
+ j ++;
+ }
+ ;
+ tmp_4 = strlen((char const *)tmp->data);
+ ;
+ tmp_5 = cgc_atof(tmp->data,tmp_4 + (size_t)1,is_bad_formula);
+ median += tmp_5;
+ tmp = tmp->next;
+ ;
+ tmp_6 = strlen((char const *)tmp->data);
+ ;
+ tmp_7 = cgc_atof(tmp->data,tmp_6 + (size_t)1,is_bad_formula);
+ median += tmp_7;
+ median /= (double)2;
+ }
+ else {
+ double tmp_9;
+ size_t tmp_8;
+ j = 0;
+ while ((size_t)j < i / (size_t)2) {
+ tmp = tmp->next;
+ j ++;
+ }
+ ;
+ tmp_8 = strlen((char const *)tmp->data);
+ ;
+ tmp_9 = cgc_atof(tmp->data,tmp_8 + (size_t)1,is_bad_formula);
+ median += tmp_9;
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ median = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ cgc_clear_stack(& sorted);
+ return median;
+}
+
+double cgc_handle_op_min(stack_t **args, int *is_bad_formula)
+{
+ double operand;
+ size_t i = (unsigned int)0;
+ double min = 0.0;
+ if (*args == (stack_t *)0) goto error;
+ char *front = cgc_pop_copy(args);
+ if (front != (char *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ min = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ i += (size_t)1;
+ }
+ front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_1;
+ ;
+ tmp_1 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_1 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (operand < min) min = operand;
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ min = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ return min;
+}
+
+double cgc_handle_op_stddev(stack_t **args, int *is_bad_formula)
+{
+ double operand;
+ double tmp_3;
+ size_t i = (unsigned int)0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ double mean = 0.0;
+ stack_t *tmp = *args;
+ while (tmp != (stack_t *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)tmp->data);
+ ;
+ operand = cgc_atof(tmp->data,tmp_0 + (size_t)1,is_bad_formula);
+ if (*is_bad_formula) goto error;
+ mean += operand;
+ i += (size_t)1;
+ tmp = tmp->next;
+ }
+ if (i == (size_t)0) goto done;
+ mean /= (double)i;
+ i = (unsigned int)0;
+ char *front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_2;
+ ;
+ tmp_2 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_2 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ result += (operand - mean) * (operand - mean);
+ front = cgc_pop_copy(args);
+ i += (size_t)1;
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ if (i == (size_t)0) {
+ i = (unsigned int)1;
+ goto error;
+ }
+ tmp_3 = sqrt(result / (double)i);
+ return tmp_3;
+}
+
+double cgc_handle_op_abs(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = fabs(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_add(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ double operand2;
+ char *front;
+ size_t tmp;
+ size_t tmp_0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand2 = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = operand1 + operand2;
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_cos(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = cos(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_ln(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ if (operand1 == (double)0) goto error;
+ result = log(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_log10(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ if (operand1 == (double)0) goto error;
+ result = log10(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_power(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ double operand2;
+ char *front;
+ size_t tmp;
+ size_t tmp_0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand2 = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ if (operand2 == 0.0) result = 1.0;
+ else
+ if (operand2 == 1.0) result = operand1;
+ else {
+ int tmp_7;
+ if (sizeof(operand2) == sizeof(float)) {
+ int tmp_5;
+ tmp_5 = __fc_fpclassifyf((float)operand2);
+ tmp_7 = tmp_5 == 0;
+ }
+ else {
+ int tmp_6;
+ tmp_6 = __fc_fpclassify(operand2);
+ tmp_7 = tmp_6 == 0;
+ }
+ if (tmp_7) result = operand2;
+ else
+ if (operand1 == (double)0) {
+ if (operand2 > (double)0) result = 0.0; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (operand1 < (double)0) {
+ double tmp_4;
+ tmp_4 = remainder(operand2,(double)1);
+ if (tmp_4 == 0.0) {
+ double tmp_1;
+ int tmp_3;
+ double tmp_2;
+ tmp_1 = pow(- operand1,operand2);
+ tmp_2 = remainder(operand2,(double)2);
+ if (tmp_2 == (double)0) tmp_3 = 1; else tmp_3 = -1;
+ result = tmp_1 * (double)tmp_3;
+ }
+ else result = pow(operand1,operand2);
+ }
+ else result = pow(operand1,operand2);
+ }
+ }
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_product(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ double operand2;
+ char *front;
+ size_t tmp;
+ size_t tmp_0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand2 = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = operand1 * operand2;
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_quotient(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ double operand2;
+ char *front;
+ size_t tmp;
+ size_t tmp_0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand2 = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ if (operand2 == (double)0) goto error;
+ result = operand1 / operand2;
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_sin(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = sin(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_sqrt(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ char *front;
+ size_t tmp;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ if (operand1 < (double)0) goto error;
+ result = sqrt(operand1);
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_subtract(stack_t **args, int *is_bad_formula)
+{
+ double operand1;
+ double operand2;
+ char *front;
+ size_t tmp;
+ size_t tmp_0;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp = strlen((char const *)front);
+ ;
+ operand1 = cgc_atof(front,tmp + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ front = cgc_pop_copy(args);
+ if (front == (char *)0) goto error;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand2 = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ if (*args != (stack_t *)0) goto error;
+ result = operand1 - operand2;
+ goto done;
+ error: cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+double cgc_handle_op_sum(stack_t **args, int *is_bad_formula)
+{
+ double operand;
+ if (*args == (stack_t *)0) goto error;
+ double result = 0.0;
+ char *front = cgc_pop_copy(args);
+ while (front != (char *)0) {
+ size_t tmp_0;
+ ;
+ tmp_0 = strlen((char const *)front);
+ ;
+ operand = cgc_atof(front,tmp_0 + (size_t)1,is_bad_formula);
+ free((void *)front);
+ if (*is_bad_formula) goto error;
+ result += operand;
+ front = cgc_pop_copy(args);
+ }
+ goto done;
+ error: *is_bad_formula = 1;
+ result = 0.0;
+ done: ;
+ return result;
+}
+
+int cgc_strtrim(char *str, size_t size, int sides)
+{
+ int __retres;
+ int i;
+ int len;
+ size_t tmp;
+ tmp = strlen((char const *)str);
+ len = (int)(tmp + (size_t)1);
+ if ((size_t)len > size) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (len == 1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (sides == 1) goto _LOR;
+ else
+ if (sides == 3) {
+ _LOR:
+ {
+ char *tmp_0 = str;
+ i = 0;
+ while (i < len) {
+ {
+ char *tmp_1;
+ tmp_1 = strchr("\r\n\t ",(int)*tmp_0);
+ if (tmp_1 == (char *)0) {
+ memcpy((void *)str,(void const *)tmp_0,(unsigned int)(len - i));
+ break;
+ }
+ }
+ i ++;
+ tmp_0 ++;
+ }
+ }
+ }
+ if (sides == 2) goto _LOR_0;
+ else
+ if (sides == 3) {
+ _LOR_0: ;
+ if (len - 1 != 0) {
+ i = len - 2;
+ while (i >= 0) {
+ {
+ char *tmp_2;
+ tmp_2 = strchr("\r\n\t ",(int)*(str + i));
+ if (tmp_2 == (char *)0) {
+ *(str + (i + 1)) = (char)'\000';
+ break;
+ }
+ else
+ if (i == 0) {
+ *(str + i) = (char)'\000';
+ break;
+ }
+ }
+ i --;
+ }
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_valid_cell_id(char *input)
+{
+ int __retres;
+ size_t tmp;
+ char row[3];
+ char col[3];
+ int tmp_0;
+ int tmp_1;
+ tmp = strlen((char const *)input);
+ if (tmp < (size_t)2) {
+ __retres = -1;
+ goto return_label;
+ }
+ size_t i = (unsigned int)0;
+ size_t is_num = (unsigned int)0;
+ char delim = (char)'\000';
+ tmp_0 = toupper((int)*(input + 0));
+ char c = (char)tmp_0;
+ if ((int)c < 'A') {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if ((int)c > 'Z') {
+ __retres = -1;
+ goto return_label;
+ }
+ row[0] = c;
+ tmp_1 = toupper((int)*(input + 1));
+ c = (char)tmp_1;
+ if ((int)c >= 'A') {
+ if (! ((int)c <= 'Z')) goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)c >= '0') {
+ if (! ((int)c <= '9')) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if ((int)c >= '0') {
+ if ((int)c <= '9') {
+ size_t tmp_2;
+ tmp_2 = is_num;
+ is_num += (size_t)1;
+ col[tmp_2] = c;
+ row[1] = (char)'\000';
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: {
+ row[1] = c;
+ row[2] = (char)'\000';
+ }
+ }
+ i = (unsigned int)2;
+ while (i < (size_t)5) {
+ if ((int)*(input + i) == (int)delim)
+ if (is_num) {
+ col[is_num] = (char)'\000';
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(input + i) >= '0') {
+ if ((int)*(input + i) <= '9') {
+ if (is_num < (size_t)2) {
+ size_t tmp_3;
+ tmp_3 = is_num;
+ is_num += (size_t)1;
+ col[tmp_3] = *(input + i);
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ i += (size_t)1;
+ }
+ __retres = -1;
+ return_label: return __retres;
+}
+
+int cgc_get_rowcol(char *input, char *row, char *col, char delim)
+{
+ int __retres;
+ size_t tmp;
+ int tmp_0;
+ int tmp_1;
+ tmp = strlen((char const *)input);
+ if (tmp < (size_t)2) {
+ __retres = -1;
+ goto return_label;
+ }
+ size_t i = (unsigned int)0;
+ size_t is_num = (unsigned int)0;
+ tmp_0 = toupper((int)*(input + 0));
+ char c = (char)tmp_0;
+ if ((int)c < 'A') {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if ((int)c > 'Z') {
+ __retres = -1;
+ goto return_label;
+ }
+ *(row + 0) = c;
+ tmp_1 = toupper((int)*(input + 1));
+ c = (char)tmp_1;
+ if ((int)c >= 'A') {
+ if (! ((int)c <= 'Z')) goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)c >= '0') {
+ if (! ((int)c <= '9')) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if ((int)c >= '0') {
+ if ((int)c <= '9') {
+ size_t tmp_2;
+ tmp_2 = is_num;
+ is_num += (size_t)1;
+ *(col + tmp_2) = c;
+ *(row + 1) = (char)'\000';
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: {
+ *(row + 1) = c;
+ *(row + 2) = (char)'\000';
+ }
+ }
+ i = (unsigned int)2;
+ while (i < (size_t)5) {
+ if ((int)*(input + i) == (int)delim)
+ if (is_num) {
+ *(col + is_num) = (char)'\000';
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(input + i) >= '0') {
+ if ((int)*(input + i) <= '9') {
+ if (is_num < (size_t)2) {
+ size_t tmp_3;
+ tmp_3 = is_num;
+ is_num += (size_t)1;
+ *(col + tmp_3) = *(input + i);
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ i += (size_t)1;
+ }
+ __retres = -1;
+ return_label: return __retres;
+}
+
+int cgc_sanitize_formula(char *formula, size_t size)
+{
+ int __retres;
+ size_t i;
+ size_t j;
+ size_t len;
+ len = strlen((char const *)formula);
+ if (len > size) {
+ __retres = -1;
+ goto return_label;
+ }
+ char *sanitized = calloc((unsigned int)1,size);
+ if (sanitized == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ i = (unsigned int)0;
+ j = (unsigned int)0;
+ while (i < len) {
+ {
+ char *tmp_1;
+ tmp_1 = strchr("\r\n\t ",(int)*(formula + i));
+ if (tmp_1 == (char *)0) {
+ size_t tmp_0;
+ tmp_0 = j;
+ j += (size_t)1;
+ *(sanitized + tmp_0) = *(formula + i);
+ }
+ }
+ i += (size_t)1;
+ }
+ memcpy((void *)formula,(void const *)sanitized,size);
+ free((void *)sanitized);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+double cgc_atof(char *str, size_t size, int *bad_conversion)
+{
+ double __retres;
+ if (str == (char *)0) goto error;
+ else {
+ size_t tmp;
+ tmp = strlen((char const *)str);
+ ;
+ if (tmp >= size) goto error;
+ else {
+ size_t tmp_0;
+ tmp_0 = strlen((char const *)str);
+ if (tmp_0 == (size_t)0) goto error;
+ }
+ }
+ double val = 0.0;
+ double exp_0 = 0.0;
+ double dec_multiplier = 1.0;
+ int has_period = 0;
+ int has_exp = 0;
+ int negative = 1;
+ int num_dec = 0;
+ if ((int)*str == '-') {
+ str ++;
+ if ((int)*str == '\000') goto error;
+ negative = -1;
+ }
+ while ((int)*str != '\000') {
+ if ((int)*str >= '0') {
+ if ((int)*str <= '9')
+ if (has_exp) exp_0 = exp_0 * (double)10 + (double)((int)*str - '0');
+ else
+ if (! has_period) val = val * (double)10 + (double)((int)*str - '0');
+ else {
+ dec_multiplier *= (double)10;
+ num_dec ++;
+ val += (double)((int)*str - '0') / dec_multiplier;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)*str == '.') has_period ++;
+ else {
+ int tmp_1;
+ tmp_1 = tolower((int)*str);
+ if (tmp_1 == 'e') has_exp ++; else goto error;
+ }
+ }
+ if (has_period > 1) goto error;
+ else
+ if (has_exp > 1) goto error;
+ if (num_dec >= 5) goto done;
+ str ++;
+ }
+ goto done;
+ error: *bad_conversion = 1;
+ __retres = 0.0;
+ goto return_label;
+ done: ;
+ if (has_exp) {
+ double tmp_2;
+ tmp_2 = pow((double)10,exp_0);
+ val *= tmp_2;
+ }
+ __retres = val * (double)negative;
+ return_label: return __retres;
+}
+
+char *cgc_ftoa(double value, char *str, size_t size)
+{
+ char *__retres;
+ int tmp_1;
+ double tmp_6;
+ double tmp_7;
+ double tmp_9;
+ if (size <= (size_t)1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ if (sizeof(value) == sizeof(float)) {
+ int tmp;
+ tmp = __fc_fpclassifyf((float)value);
+ tmp_1 = tmp == 1;
+ }
+ else {
+ int tmp_0;
+ tmp_0 = __fc_fpclassify(value);
+ tmp_1 = tmp_0 == 1;
+ }
+ if (tmp_1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else {
+ int tmp_4;
+ if (sizeof(value) == sizeof(float)) {
+ int tmp_2;
+ tmp_2 = __fc_fpclassifyf((float)value);
+ tmp_4 = tmp_2 == 0;
+ }
+ else {
+ int tmp_3;
+ tmp_3 = __fc_fpclassify(value);
+ tmp_4 = tmp_3 == 0;
+ }
+ if (tmp_4) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ }
+ size_t i = (unsigned int)0;
+ int negative = 0;
+ if (value < (double)0) {
+ size_t tmp_5;
+ negative = 1;
+ tmp_5 = i;
+ i += (size_t)1;
+ *(str + tmp_5) = (char)'-';
+ value *= (double)(-1);
+ }
+ if (i == size) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ tmp_6 = remainder(value,0.001);
+ tmp_7 = pow((double)10,(double)4);
+ double rem = tmp_6 * tmp_7;
+ if (rem > (double)5) goto _LOR;
+ else
+ if (rem < (double)0)
+ if (rem > (double)(-5))
+ _LOR:
+ if (! negative) value += 0.0005;
+ else
+ if (negative) value += 0.0005;
+ if (value == (double)0) tmp_9 = (double)0; else tmp_9 = log10(value);
+ int magnitude = (int)tmp_9;
+ if (magnitude < 0) magnitude = 0;
+ while (magnitude > -4) {
+ {
+ size_t tmp_12;
+ if (i == size) break;
+ if (magnitude == -1) {
+ size_t tmp_10;
+ tmp_10 = i;
+ i += (size_t)1;
+ *(str + tmp_10) = (char)'.';
+ if (i == size) break;
+ }
+ double e = pow((double)10,(double)magnitude);
+ int digit = (int)(value / e);
+ value -= (double)digit * e;
+ tmp_12 = i;
+ i += (size_t)1;
+ *(str + tmp_12) = (char)(digit + '0');
+ }
+ magnitude --;
+ }
+ if (i == size) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else *(str + i) = (char)'\000';
+ __retres = str;
+ return_label: return __retres;
+}
+
+char *cgc_itoa(int value, char *str, size_t size)
+{
+ char *__retres;
+ size_t tmp_2;
+ int base = 10;
+ if (size <= (size_t)1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ size_t i = (unsigned int)0;
+ int is_negative = 0;
+ if (value < 0) is_negative = 1;
+ while (1) {
+ if (is_negative) {
+ size_t tmp;
+ tmp = i;
+ i += (size_t)1;
+ *(str + tmp) = (char)('0' - value % base);
+ }
+ else {
+ size_t tmp_0;
+ tmp_0 = i;
+ i += (size_t)1;
+ *(str + tmp_0) = (char)('0' + value % base);
+ }
+ value /= base;
+ if (i < size - (size_t)1) {
+ if (! (value != 0)) break;
+ }
+ else break;
+ }
+ if (value != 0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else
+ if (i == size - (size_t)1)
+ if (is_negative) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ if (is_negative) {
+ size_t tmp_1;
+ tmp_1 = i;
+ i += (size_t)1;
+ *(str + tmp_1) = (char)'-';
+ }
+ tmp_2 = i;
+ i -= (size_t)1;
+ *(str + tmp_2) = (char)'\000';
+ int j = 0;
+ while (i > (size_t)j) {
+ int tmp_3;
+ size_t tmp_4;
+ char c = *(str + j);
+ tmp_3 = j;
+ j ++;
+ *(str + tmp_3) = *(str + i);
+ tmp_4 = i;
+ i -= (size_t)1;
+ *(str + tmp_4) = c;
+ }
+ __retres = str;
+ return_label: return __retres;
+}
+
+static void cgc_print_table(void)
+{
+ cgc_print_assigned_cells();
+ return;
+}
+
+static int cgc_readline(int fd, char *line, size_t line_size)
+{
+ int __retres;
+ size_t i;
+ size_t rx;
+ i = (unsigned int)0;
+ while (i < line_size) {
+ {
+ int tmp;
+ tmp = cgc_receive(fd,(void *)line,(unsigned int)1,& rx);
+ if (tmp != 0) exit(0);
+ else
+ if (rx == (size_t)0) exit(0);
+ if ((int)*line == '\n') break;
+ line ++;
+ }
+ i += (size_t)1;
+ }
+ if (i == line_size) {
+ if ((int)*line != '\n') {
+ __retres = -1;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)*line != '\n') {
+ __retres = 1;
+ goto return_label;
+ }
+ else *line = (char)'\000';
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_2(char const * __restrict format, char *param0);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_3(char const * __restrict format, char *param0);
+
+static int cgc_parse_line(char *line)
+{
+ int __retres;
+ size_t i;
+ char tmp[32];
+ char *tok;
+ char val_str[512];
+ char *cell_str;
+ int tmp_0;
+ size_t tmp_1;
+ int tmp_5;
+ size_t tmp_4;
+ size_t tmp_6;
+ int tmp_10;
+ size_t tmp_9;
+ size_t tmp_11;
+ int tmp_15;
+ size_t tmp_14;
+ int tmp_17;
+ size_t tmp_18;
+ int tmp_23;
+ int tmp_25;
+ size_t tmp_24;
+ int tmp_26;
+ int is_repr = 0;
+ tmp_0 = cgc_strtrim(line,(unsigned int)512,1);
+ if (tmp_0 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ tmp_1 = strlen("SHOW ");
+ ;
+ memcpy((void *)(tmp),(void const *)line,tmp_1);
+ i = (unsigned int)0;
+ while (1) {
+ size_t tmp_3;
+ int tmp_2;
+ tmp_3 = strlen("SHOW ");
+ ;
+ if (! (i < tmp_3)) break;
+ tmp_2 = toupper((int)tmp[i]);
+ tmp[i] = (char)tmp_2;
+ i += (size_t)1;
+ }
+ tmp_4 = strlen("SHOW ");
+ tmp_5 = memcmp((void const *)(tmp),(void const *)"SHOW ",tmp_4);
+ if (tmp_5 == 0) goto show_cmd;
+ tmp_6 = strlen("REPR ");
+ ;
+ memcpy((void *)(tmp),(void const *)line,tmp_6);
+ i = (unsigned int)0;
+ while (1) {
+ size_t tmp_8;
+ int tmp_7;
+ tmp_8 = strlen("REPR ");
+ ;
+ if (! (i < tmp_8)) break;
+ tmp_7 = toupper((int)tmp[i]);
+ tmp[i] = (char)tmp_7;
+ i += (size_t)1;
+ }
+ tmp_9 = strlen("REPR ");
+ tmp_10 = memcmp((void const *)(tmp),(void const *)"REPR ",tmp_9);
+ if (tmp_10 == 0) {
+ is_repr = 1;
+ goto show_cmd;
+ }
+ tmp_11 = strlen("CLEAR ");
+ ;
+ memcpy((void *)(tmp),(void const *)line,tmp_11);
+ i = (unsigned int)0;
+ while (1) {
+ size_t tmp_13;
+ int tmp_12;
+ tmp_13 = strlen("CLEAR ");
+ ;
+ if (! (i < tmp_13)) break;
+ tmp_12 = toupper((int)tmp[i]);
+ tmp[i] = (char)tmp_12;
+ i += (size_t)1;
+ }
+ tmp_14 = strlen("CLEAR ");
+ tmp_15 = memcmp((void const *)(tmp),(void const *)"CLEAR ",tmp_14);
+ if (tmp_15 == 0) goto clear_cmd;
+ memcpy((void *)(tmp),(void const *)line,sizeof("EXIT"));
+ i = (unsigned int)0;
+ while (i < sizeof("EXIT")) {
+ int tmp_16;
+ tmp_16 = toupper((int)tmp[i]);
+ tmp[i] = (char)tmp_16;
+ i += (size_t)1;
+ }
+ tmp_17 = memcmp((void const *)(tmp),(void const *)"EXIT",sizeof("EXIT"));
+ if (tmp_17 == 0) goto exit_cmd;
+ goto assign_cmd;
+ show_cmd: cgc_strtrim(line,(unsigned int)512,2);
+ tmp_18 = strlen("SHOW ");
+ ;
+ memcpy((void *)(tmp),(void const *)(line + tmp_18),sizeof("TABLE"));
+ i = (unsigned int)0;
+ while (i < sizeof("TABLE")) {
+ int tmp_19;
+ tmp_19 = toupper((int)tmp[i]);
+ tmp[i] = (char)tmp_19;
+ i += (size_t)1;
+ }
+ tmp_23 = memcmp((void const *)(tmp),(void const *)"TABLE",sizeof("TABLE"));
+ if (tmp_23 == 0) {
+ cgc_print_table();
+ __retres = 0;
+ goto return_label;
+ }
+ else {
+ int tmp_22;
+ size_t tmp_21;
+ tmp_21 = strlen("SHOW ");
+ ;
+ tmp_22 = cgc_valid_cell_id(line + tmp_21);
+ if (tmp_22 != -1) {
+ size_t tmp_20;
+ ;
+ tmp_20 = strlen("SHOW ");
+ ;
+ cell_str = cgc_show_cell(line + tmp_20,is_repr,val_str,
+ (unsigned int)512);
+ if (is_repr) printf_va_2("Cell Repr: %s\n",cell_str);
+ else printf_va_3("Cell Value: %s\n",cell_str);
+ __retres = 0;
+ goto return_label;
+ }
+ else {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ clear_cmd:
+ {
+ tmp_24 = strlen("CLEAR ");
+ ;
+ tmp_25 = cgc_clear_cell(line + tmp_24);
+ }
+ if (tmp_25 != 0) {
+ __retres = -8;
+ goto return_label;
+ }
+ __retres = 0;
+ goto return_label;
+ assign_cmd: tok = strsep(& line,"=");
+ if (tok == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (line == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ tmp_26 = cgc_set_cell(tok,line,(unsigned int)512);
+ if (tmp_26 != 0) {
+ __retres = -4;
+ goto return_label;
+ }
+ __retres = 0;
+ goto return_label;
+ exit_cmd: __retres = 1;
+ return_label: return __retres;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_4(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_5(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_6(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_7(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_8(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_9(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_10(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_11(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_12(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_13(char const * __restrict format);
+
+int main(int cgc_argc, char **cgc_argv)
+{
+ int __retres;
+ char line[512];
+ int line_status;
+ cgc_init_sheet();
+ int exit_0 = 0;
+ while (1) {
+ {
+ int tmp;
+ printf_va_4("Accel:-$ ");
+ line_status = cgc_readline(0,line,(unsigned int)512);
+ if (line_status != 0) {
+ printf_va_5("\n");
+ goto __Cont;
+ }
+ tmp = cgc_parse_line(line);
+ switch (tmp) {
+ case -8: printf_va_6("Error clearing cell\n");
+ break;
+ case -4: printf_va_7("Error assigning cell. Valid Cells: A0-ZZ99\n");
+ break;
+ case -2:
+ printf_va_8("Error showing data. Try SHOW TABLE or SHOW [A0-ZZ99]\n");
+ break;
+ case -1: printf_va_9("Bad input\n");
+ break;
+ case 0: printf_va_10("Success.\n");
+ break;
+ case 1: exit_0 = 1;
+ printf_va_11("Exiting...\n");
+ __retres = 0;
+ goto return_label;
+ default: printf_va_12("Unknown Input\n");
+ break;
+ }
+ }
+ __Cont: if (! (! exit_0)) break;
+ }
+ printf_va_13("Unsupported signal. Exiting...\n");
+ __retres = 0;
+ return_label: return __retres;
+}
+
+char *cgc_peek_front(queue_t *queue)
+{
+ char *__retres;
+ if (queue == (queue_t *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ __retres = queue->data;
+ return_label: return __retres;
+}
+
+int cgc_enqueue(queue_t **queue, char *data)
+{
+ int __retres;
+ if (data == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ queue_t *back = malloc(sizeof(queue_t));
+ back->data = data;
+ back->next = (queue_t *)0;
+ if (*queue == (queue_t *)0) *queue = back;
+ else {
+ queue_t *iter = *queue;
+ while (iter->next != (queue_t *)0) iter = iter->next;
+ iter->next = back;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_enqueue_copy(queue_t **queue, char *data, size_t size)
+{
+ int __retres;
+ size_t tmp;
+ if (data == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ tmp = strlen((char const *)data);
+ int data_len = (int)(tmp + (size_t)1);
+ if ((size_t)data_len > size) {
+ __retres = -1;
+ goto return_label;
+ }
+ queue_t *back = malloc(sizeof(queue_t));
+ back->data = (char *)malloc((unsigned int)data_len);
+ memcpy((void *)back->data,(void const *)data,(unsigned int)data_len);
+ back->next = (queue_t *)0;
+ if (*queue == (queue_t *)0) *queue = back;
+ else {
+ queue_t *iter = *queue;
+ while (iter->next != (queue_t *)0) iter = iter->next;
+ iter->next = back;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+char *cgc_dequeue_copy(queue_t **queue)
+{
+ char *__retres;
+ if (*queue == (queue_t *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ queue_t *front = *queue;
+ char *popped_data = front->data;
+ *queue = front->next;
+ free((void *)front);
+ __retres = popped_data;
+ return_label: return __retres;
+}
+
+void cgc_clear_queue(queue_t **queue)
+{
+ queue_t *old_front;
+ if (*queue == (queue_t *)0) goto return_label;
+ queue_t *front = *queue;
+ while (front->next != (queue_t *)0) {
+ free((void *)front->data);
+ old_front = front;
+ front = front->next;
+ free((void *)old_front);
+ }
+ free((void *)front->data);
+ free((void *)front);
+ *queue = (queue_t *)0;
+ return_label: return;
+}
+
+char *cgc_peek_top(stack_t *stack)
+{
+ char *__retres;
+ if (stack == (stack_t *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ __retres = stack->data;
+ return_label: return __retres;
+}
+
+int cgc_push(stack_t **stack, char *data)
+{
+ int __retres;
+ if (data == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ stack_t *top = malloc(sizeof(stack_t));
+ top->data = data;
+ if (*stack == (stack_t *)0) {
+ top->next = (stack_t *)0;
+ *stack = top;
+ }
+ else {
+ top->next = *stack;
+ *stack = top;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int cgc_push_copy(stack_t **stack, char *data, size_t size)
+{
+ int __retres;
+ size_t tmp;
+ if (data == (char *)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ tmp = strlen((char const *)data);
+ int data_len = (int)(tmp + (size_t)1);
+ if ((size_t)data_len > size) {
+ __retres = -1;
+ goto return_label;
+ }
+ stack_t *top = malloc(sizeof(stack_t));
+ top->data = (char *)malloc((unsigned int)data_len);
+ memcpy((void *)top->data,(void const *)data,(unsigned int)data_len);
+ if (*stack == (stack_t *)0) {
+ top->next = (stack_t *)0;
+ *stack = top;
+ }
+ else {
+ top->next = *stack;
+ *stack = top;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+char *cgc_pop_copy(stack_t **stack)
+{
+ char *__retres;
+ if (*stack == (stack_t *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ stack_t *top = *stack;
+ char *popped_data = top->data;
+ *stack = top->next;
+ free((void *)top);
+ __retres = popped_data;
+ return_label: return __retres;
+}
+
+void cgc_clear_stack(stack_t **stack)
+{
+ stack_t *old_top;
+ if (*stack == (stack_t *)0) goto return_label;
+ stack_t *top = *stack;
+ while (top->next != (stack_t *)0) {
+ free((void *)top->data);
+ old_top = top;
+ top = top->next;
+ free((void *)old_top);
+ }
+ free((void *)top->data);
+ free((void *)top);
+ *stack = (stack_t *)0;
+ return_label: return;
+}
+
+
diff --git a/cgc-challenges/Accel/.frama-c/Accel.parse/metrics.log b/cgc-challenges/Accel/.frama-c/Accel.parse/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..c1e9dc08db214725d92354d3e58a690fa4e651b1
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.parse/metrics.log
@@ -0,0 +1,66 @@
+[metrics] Defined functions (63)
+======================
+ cgc__terminate (0 call); cgc_allocate (0 call); cgc_atof (32 calls);
+ cgc_check_timeout (1 call); cgc_clear_cell (1 call);
+ cgc_clear_queue (3 calls); cgc_clear_stack (21 calls);
+ cgc_copy_cgc_fd_set (2 calls); cgc_copy_os_fd_set (2 calls);
+ cgc_deallocate (0 call); cgc_dequeue_copy (1 call); cgc_enqueue (6 calls);
+ cgc_enqueue_copy (2 calls); cgc_eval_formula (2 calls);
+ cgc_eval_function (2 calls); cgc_fdwait (0 call); cgc_ftoa (3 calls);
+ cgc_get_cell (4 calls); cgc_get_op (3 calls); cgc_get_rowcol (1 call);
+ cgc_handle_op_abs (address taken) (0 call);
+ cgc_handle_op_add (address taken) (0 call);
+ cgc_handle_op_avg (address taken) (0 call);
+ cgc_handle_op_cos (address taken) (0 call);
+ cgc_handle_op_count (address taken) (0 call);
+ cgc_handle_op_ln (address taken) (0 call);
+ cgc_handle_op_log10 (address taken) (0 call);
+ cgc_handle_op_max (address taken) (0 call);
+ cgc_handle_op_median (address taken) (0 call);
+ cgc_handle_op_min (address taken) (0 call);
+ cgc_handle_op_power (address taken) (0 call);
+ cgc_handle_op_product (address taken) (0 call);
+ cgc_handle_op_quotient (address taken) (0 call);
+ cgc_handle_op_sin (address taken) (0 call);
+ cgc_handle_op_sqrt (address taken) (0 call);
+ cgc_handle_op_stddev (address taken) (0 call);
+ cgc_handle_op_subtract (address taken) (0 call);
+ cgc_handle_op_sum (address taken) (0 call); cgc_infixtorpn (1 call);
+ cgc_init_sheet (1 call); cgc_is_arg_arithmetic (1 call); cgc_itoa (4 calls);
+ cgc_parse_line (1 call); cgc_parsearg (5 calls); cgc_peek_front (0 call);
+ cgc_peek_top (13 calls); cgc_pop_copy (44 calls);
+ cgc_print_assigned_cells (1 call); cgc_print_table (1 call);
+ cgc_push (4 calls); cgc_push_copy (10 calls); cgc_random (0 call);
+ cgc_readline (1 call); cgc_receive (2 calls); cgc_sanitize_formula (1 call);
+ cgc_set_cell (1 call); cgc_show_cell (1 call); cgc_strtrim (2 calls);
+ cgc_transmit (0 call); cgc_try_init_prng (1 call);
+ cgc_valid_cell_id (2 calls); main (0 call); receive_bytes_iPcz (0 call);
+
+Undefined functions (5)
+=======================
+ cgc_aes_get_bytes (1 call); cgc_init_prng (1 call);
+ cgc_initialize_flag_page (0 call); cgc_prng (0 call); seed_prng (0 call);
+
+'Extern' global variables (0)
+=============================
+
+
+Potential entry points (9)
+==========================
+ cgc__terminate; cgc_allocate; cgc_deallocate; cgc_fdwait; cgc_peek_front;
+ cgc_random; cgc_transmit; main; receive_bytes_iPcz;
+
+Global metrics
+==============
+Sloc = 2311
+Decision point = 430
+Global variables = 5
+If = 412
+Loop = 54
+Goto = 275
+Assignment = 897
+Exit point = 63
+Function = 68
+Function call = 426
+Pointer dereferencing = 300
+Cyclomatic complexity = 493
diff --git a/cgc-challenges/Accel/.frama-c/Accel.parse/warnings.log b/cgc-challenges/Accel/.frama-c/Accel.parse/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..2ed1130a721b395addb090f14b9d7d093549fc44
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/Accel.parse/warnings.log
@@ -0,0 +1,10 @@
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accel.c:372:[kernel:typing:no-proto] warning: Calling function cgc_clear_stack that is declared without prototype.
+Its formals will be inferred from actual arguments
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/accelfunc.c:53:[kernel:typing:no-proto] warning: Calling function cgc_clear_stack that is declared without prototype.
+Its formals will be inferred from actual arguments
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/ftoa.c:50:[kernel:parser:decimal-float] warning: Floating-point constant 0.001 is not represented exactly. Will use 0x1.0624dd2f1a9fcp-10.
+(warn-once: no further messages from category 'parser:decimal-float' will be emitted)
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:51:[kernel:typing:no-proto] warning: Calling function cgc_print_assigned_cells that is declared without prototype.
+Its formals will be inferred from actual arguments
+/home/andr/git/oscs-pub3/cgc-challenges/Accel/main.c:165:[kernel:typing:no-proto] warning: Calling function cgc_init_sheet that is declared without prototype.
+Its formals will be inferred from actual arguments
diff --git a/cgc-challenges/Accel/.frama-c/GNUmakefile b/cgc-challenges/Accel/.frama-c/GNUmakefile
new file mode 100644
index 0000000000000000000000000000000000000000..eca7672b3b04ec4dcc513ac06365534afb9dfb1e
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/GNUmakefile
@@ -0,0 +1,53 @@
+# Makefile template for Frama-C/Eva case studies.
+# For details and usage information, see the Frama-C User Manual.
+
+### Prologue. Do not modify this block. #######################################
+-include path.mk
+FRAMAC ?= frama-c
+include $(shell $(FRAMAC)-config -scripts)/prologue.mk
+###############################################################################
+
+# Edit below as needed. MACHDEP is mandatory. Suggested flags are optional.
+
+MACHDEP = x86_32
+
+## Preprocessing flags (for -cpp-extra-args)
+CPPFLAGS += \
+ -DPATCHED \
+ -I../../lib \
+
+## General flags
+FCFLAGS += \
+ -add-symbolic-path=..:. \
+ -kernel-warn-key annot:missing-spec=abort \
+ -kernel-warn-key typing:implicit-function-declaration=abort \
+ -absolute-valid-range 0x4347C000-0x4347FFFF \
+
+## Eva-specific flags
+EVAFLAGS += \
+ -eva-warn-key builtins:missing-spec=abort \
+ -eva-use-spec cgc_eval_formula \
+
+## GUI-only flags
+FCGUIFLAGS += \
+
+## Analysis targets (suffixed with .eva)
+TARGETS = Accel.eva
+
+### Each target <t>.eva needs a rule <t>.parse with source files as prerequisites
+Accel.parse: \
+ ../../lib/common.c \
+ ../../lib/libcgc.c \
+ ../accel.c \
+ ../accelfunc.c \
+ ../accelio.c \
+ ../atof.c \
+ ../ftoa.c \
+ ../itoa.c \
+ ../main.c \
+ ../queue.c \
+ ../stack.c \
+
+### Epilogue. Do not modify this block. #######################################
+include $(shell $(FRAMAC)-config -scripts)/epilogue.mk
+###############################################################################
diff --git a/cgc-challenges/Accel/.frama-c/path.mk b/cgc-challenges/Accel/.frama-c/path.mk
new file mode 120000
index 0000000000000000000000000000000000000000..222d0e04958ae14f92c8910637128c93b6f3dd09
--- /dev/null
+++ b/cgc-challenges/Accel/.frama-c/path.mk
@@ -0,0 +1 @@
+../../frama-c-cgc-path.mk
\ No newline at end of file
diff --git a/cgc-challenges/Accel/FRAMAC_README.md b/cgc-challenges/Accel/FRAMAC_README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c4e0c4a3ef6f810243c4b8d411711c1a435e59f6
--- /dev/null
+++ b/cgc-challenges/Accel/FRAMAC_README.md
@@ -0,0 +1 @@
+# contains recursive calls (cgc_eval_formula), stubbed unsoundly
diff --git a/cgc-challenges/Accel/README.md b/cgc-challenges/Accel/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e012bd357883bf04926bd68f7cf6ddb9eaf24f87
--- /dev/null
+++ b/cgc-challenges/Accel/README.md
@@ -0,0 +1,84 @@
+# KPRCA-00013
+
+### DARPA performer group
+Kaprica Security (KPRCA)
+
+## Description
+
+Accel is a spreadsheet program that enables a user to store information in a table and calculate numerical formulas based on cell data. Similar to other familiar spreadsheet programs, Accel is meant to assist in organizing large amounts of data that have interdependencies. The functions provided will enable a user to complete most simple financial and arithmetic needs.
+
+### Feature List
+
+Command Line Operations:
+-------------------------
+**Literal Assignment
+A0=1
+A0=This is a string
+
+**Formula Assignment
+A1==SQRT(9)
+A2==A1+97
+A3==SIN(A2/A1)
+
+Supported String Commands:
+----------------------
+CLEAR - Clears a cell
+Accel:-$ CLEAR A3
+
+REPR - Show the representation of a cell (helpful with formulas)
+Accel:-$ REPR A2 --> =A1+97
+
+SHOW - Show the value of a cell, either literal or computer
+Accel:-S SHOW A2 --> 100
+Accel:-S SHOW A0 --> This is a string
+
+SHOW TABLE - Shows the contents of the entire table
+Accel:-S SHOW TABLE
+
+EXIT - Exits the program
+Accel:-S EXIT
+
+Supported Functions:
+------------------------------------------------
+AVG - Calculate the average of a list
+COUNT - Count the number of items in a list
+MAX - Return the largest value in a list
+MEDIAN - Calculate the median of a list
+MIN - Return the smallest value in a list
+STDDEV - Calculate the standard deviation of a list
+ABS - Return the absolute value of a number
+COS - Calculate the cosine function of a number
+LN - Caclualte the natural log of a number
+LOG10 - Calculate a log base 10 of a number
+POWER - Raise a number to a power
+SIN - Calculate the sine function of a number
+SQRT - Take the square root of a number
+SUM - Return the summation of a list
+
+Supported Operators
+------------------------------------------------
++ - Addition
+* - Multiplication
+/ - Division
+- - Subtraction
+
+## Vulnerability
+
+In infixtorpn (accel.c:453), an attacker supplied string is parsed into its components. Every time a function name is encountered, it is stored in an array and the index (func_idx) is incremented. The check to test if the array needs to be enlarged is off by one, because the index is incremented between the check and the store. This results in an overflow of the heap buffer, which can allow the attacker to control the heap metadata (size) of the next heap block. Attacker control is limited because the memory is initially set to zero and then incremented every time a comma occurs, but an attacker only needs to get the value to greater than 32 or so to cause a segmentation fault. The fault occurs because the free method will try to split the memory even though it has wrong metadata and overwrite pointers on the heap.
+
+Also, there is an uninitialized variable vulnerability in handle_op_median, where sorted variable wasn't initialized before being cleared.
+
+### Generic class of vulnerability
+
+Generic type: Heap-buffer overflow
+
+Uninitialized variable
+
+### CWE classification
+
+CWE-193: Off-by-one Error
+CWE-457: Use of Uninitialized Variable
+
+## Challenges
+
+This cb is meant to be difficult to analyze. The program should provide complexities that are will take some work to reason about. The bug is similar, in that it's difficult to detect what is or isn't a heap overflow especially when dealing with an off-by-one error.
diff --git a/cgc-challenges/Accel/accel.c b/cgc-challenges/Accel/accel.c
new file mode 100644
index 0000000000000000000000000000000000000000..8bd552be0f100206b46881bc09470e51ab78251f
--- /dev/null
+++ b/cgc-challenges/Accel/accel.c
@@ -0,0 +1,654 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "common.h"
+#include "libcgc.h"
+
+#include "cgc_accel.h"
+#include "cgc_accelio.h"
+#include "cgc_accelfunc.h"
+
+#include "cgc_stack.h"
+#include "cgc_queue.h"
+
+#include "cgc_convert.h"
+
+#define LINE_SIZE 512
+#define TMP_STR_SIZE 512
+#define MAX_ROWS 26 * 27
+#define MAX_COLS 100
+
+typedef enum { UNUSED, BAD_CELL, STRING, QUOTED_STRING, DOUBLE, FUNCTION, CELL_ID, FORMULA } cell_type_e;
+typedef struct cell {
+ unsigned int id;
+ cell_type_e cell_type;
+ char *str;
+ char *formula;
+} cell_t;
+
+static operator_t *cgc_get_op(char *name);
+static cell_type_e cgc_parsearg(char *arg);
+static int cgc_is_arg_arithmetic(char *arg);
+static cell_t *cgc_get_cell(char *cell_id);
+static queue_t *cgc_infixtorpn(char *infix, size_t size);
+static double cgc_eval_formula(char *formula, int *is_bad_formula, stack_t **cir_ref, int id);
+
+static cell_t *_g_sheet = NULL;
+static cell_t **g_sheet = NULL;
+
+static operator_t operators[] =
+{
+ { "AVG", cgc_handle_op_avg },
+ { "COUNT", cgc_handle_op_count },
+ { "MAX", cgc_handle_op_max },
+ { "MEDIAN", cgc_handle_op_median },
+ { "MIN", cgc_handle_op_min },
+ { "STDDEV", cgc_handle_op_stddev },
+ { "ABS", cgc_handle_op_abs },
+ { "+", cgc_handle_op_add },
+ { "COS", cgc_handle_op_cos },
+ { "LN", cgc_handle_op_ln },
+ { "LOG10", cgc_handle_op_log10 },
+ { "POWER", cgc_handle_op_power },
+ { "*", cgc_handle_op_product },
+ { "/", cgc_handle_op_quotient },
+ { "SIN", cgc_handle_op_sin },
+ { "SQRT", cgc_handle_op_sqrt },
+ { "-", cgc_handle_op_subtract },
+ { "SUM", cgc_handle_op_sum },
+ { NULL, NULL}
+};
+
+int cgc_init_sheet()
+{
+ size_t i, j;
+ unsigned int id = 0;
+ // LARGEST SHEET SIZE: ZZ99 (676 rows by 100 columns)
+
+ _g_sheet = calloc(MAX_ROWS * MAX_COLS, sizeof(cell_t));
+ if (_g_sheet == NULL)
+ return -1;
+
+ g_sheet = malloc(MAX_ROWS * sizeof(cell_t*));
+ if (g_sheet == NULL)
+ return -1;
+
+ for (i = 0; i < MAX_ROWS; i++)
+ g_sheet[i] = &_g_sheet[i * MAX_COLS];
+
+ for (i = 0; i < MAX_ROWS; i++)
+ for (j = 0; j < MAX_COLS; j++)
+ g_sheet[i][j].id = id++;
+
+ return 0;
+}
+
+char *cgc_show_cell(char *cell_id, int is_repr, char* val_str, size_t size)
+{
+ int is_bad_formula;
+ double val = 0.0;
+ cell_t *cell = cgc_get_cell(cell_id);
+
+ if (cell == NULL)
+ return NULL;
+
+ if (cell->cell_type == UNUSED)
+ return "";
+ if (cell->cell_type == BAD_CELL)
+ return "!VALUE";
+
+ if (is_repr)
+ return cell->str;
+
+ if (cell->formula != NULL) {
+ stack_t *cir_ref = NULL;
+ val = cgc_eval_formula(cell->formula, &is_bad_formula, &cir_ref, cell->id);
+ if (is_bad_formula) {
+ return "!FORMULA: CIRREF/STR/DIV0";
+ }
+
+ cgc_ftoa(val, val_str, size);
+ return val_str;
+ } else {
+ return cell->str;
+ }
+}
+
+
+int cgc_set_cell(char *cell_id, char *cell_str, size_t size)
+{
+ if (cell_str == NULL || strlen(cell_str) == 0 || strlen(cell_str) >= size)
+ return -1;
+
+ cell_t *cell = cgc_get_cell(cell_id);
+ if (cell == NULL)
+ return -1;
+
+ if (cell->cell_type != UNUSED) {
+ free(cell->str);
+ cell->str = NULL;
+ cell->cell_type = UNUSED;
+ cell->formula = NULL;
+ }
+
+ cell->str = malloc(strlen(cell_str) + 1);
+ if(cell->str == NULL)
+ return -1;
+
+ strcpy(cell->str, cell_str);
+ if (strlen(cell_str) >= 2 && cell_str[0] == '=') {
+ cell->formula = &cell->str[1];
+ cell->cell_type = FORMULA;
+ } else {
+ // Non functions can only be a double or a string
+ cell->cell_type = cgc_parsearg(cell->str);
+ if (cell->cell_type != DOUBLE)
+ cell->cell_type = STRING;
+ }
+
+ return 0;
+}
+
+int cgc_clear_cell(char *cell_id)
+{
+
+ cell_t *cell = cgc_get_cell(cell_id);
+
+ if (cell == NULL)
+ return -1;
+
+ if (cell->cell_type != UNUSED) {
+ free(cell->str);
+ cell->str = NULL;
+ cell->cell_type = UNUSED;
+ cell->formula = NULL;
+ }
+
+ return 0;
+}
+
+void cgc_print_assigned_cells()
+{
+ char row_id[3];
+ char col_id[4];
+ size_t i, j;
+ unsigned int id;
+ cell_t *cell;
+ for (i = 0; i < MAX_ROWS; i++) {
+ for (j = 0; j < MAX_COLS; j++) {
+ cell = &g_sheet[i][j];
+ if (cell->cell_type != UNUSED) {
+ id = cell->id;
+ cgc_itoa(id % 100, col_id, sizeof(col_id));
+ row_id[2] = '\0';
+ row_id[1] = (id / (100 * 26)) == 0 ? '\0' : ((id / 100) % 26) + 'A';
+ row_id[0] = (id / (100 * 26)) == 0 ? ((id / 100) % 26) + 'A' : (((id / (100 * 26)) - 1) % 26) + 'A';
+ printf("%s%s=%s\n", row_id, col_id, cell->str);
+ }
+ }
+ }
+}
+
+static operator_t *cgc_get_op(char *name)
+{
+ if(name == NULL)
+ return NULL;
+
+ char *upper_name = (char *) malloc(strlen(name) + 1);
+ strcpy(upper_name, name);
+ size_t i, len = strlen(upper_name);
+ for (i = 0; i < len; i++)
+ upper_name[i] = toupper(upper_name[i]);
+
+ operator_t *op = NULL;
+ for (op = &operators[0]; op->name != NULL; op++) {
+ if (strcmp(op->name, upper_name) == 0)
+ break;
+ }
+
+ free(upper_name);
+ if (op->name == NULL)
+ return NULL;
+ else
+ return op;
+}
+
+static cell_type_e cgc_parsearg(char *arg)
+{
+ if (arg == NULL)
+ return BAD_CELL;
+
+ int is_double = 0, has_period = 0, has_negative = 0;
+ int is_hard_string = 0, is_soft_string = 0;
+ char *beg_arg = arg;
+
+ while (*arg != '\0') {
+ if (*arg >= '0' && *arg <= '9') {
+ is_double++;
+ } else if (*arg == '-') {
+ is_double++;
+ has_negative++;
+ } else if (*arg == '.') {
+ is_double++;
+ has_period++;
+ } else if (*arg == '"') {
+ is_hard_string++;
+ } else {
+ is_soft_string++;
+ }
+ arg++;
+ }
+ arg = beg_arg;
+
+ if (is_hard_string) {
+ if (is_hard_string == 2 && *(--arg) == '"')
+ return QUOTED_STRING;
+ else
+ return STRING;
+ } else if (is_soft_string) {
+ if (has_period > 1 || has_negative > 1)
+ return STRING;
+
+ if (cgc_valid_cell_id(arg) == 0)
+ return CELL_ID;
+
+ if (cgc_get_op(arg) != NULL)
+ return FUNCTION;
+
+ return STRING;
+ } else if (is_double) {
+ if (has_period > 1 || has_negative > 1)
+ return STRING;
+
+ if ((has_period && is_double == 1) || (has_period && has_negative && is_double == 2))
+ return STRING;
+
+ if (has_negative && is_double == 1)
+ return FUNCTION;
+
+ return DOUBLE;
+ } else {
+ return BAD_CELL;
+ }
+}
+
+static int cgc_is_arg_arithmetic(char *arg)
+{
+ return ((memcmp(arg, "+", 2) == 0) ||
+ (memcmp(arg, "-", 2) == 0) ||
+ (memcmp(arg, "/", 2) == 0) ||
+ (memcmp(arg, "*", 2) == 0));
+}
+
+static cell_t *cgc_get_cell(char *cell_id)
+{
+ char row_str[3];
+ char col_str[3];
+ int row_idx = 0, col_idx = 0;
+ int i, len;
+
+ if (cgc_get_rowcol(cell_id, row_str, col_str, '\0') == -1)
+ return NULL;
+
+ len = strlen(row_str);
+ for (i = 0; i < len; i++)
+ row_idx += ((row_str[i] - 64) * pow(26, len - i - 1));
+
+ --row_idx;
+ col_idx = strtol(col_str, NULL, 10);
+ return &g_sheet[row_idx][col_idx];
+
+}
+
+static int cgc_eval_function(operator_t *op, stack_t **values, char *val_str, size_t size)
+{
+ if (op == NULL || val_str == NULL || size <= 2)
+ return -1;
+
+ double val = 0.0;
+ char *arg;
+ char *op_name = (char *) op->name;
+ size_t i, num_args = 0;
+ int is_bad_formula = 0;
+ operator_t *nested_op;
+
+ stack_t *args = NULL;
+ if (cgc_is_arg_arithmetic(op_name)) {
+ num_args = 2;
+ } else {
+ char *arg_count = cgc_pop_copy(values);
+ if (arg_count == NULL)
+ goto error;
+
+ num_args = strtol(arg_count, NULL, 10);
+ free(arg_count);
+ }
+
+ for (i = 0; i < num_args; i++) {
+ arg = cgc_pop_copy(values);
+ //printf("arg[%d]==%s\n", i, arg);
+ if (cgc_parsearg(arg) == FUNCTION) {
+ nested_op = cgc_get_op(arg);
+ free(arg);
+ if (cgc_eval_function(nested_op, values, val_str, size) == 0)
+ cgc_push_copy(&args, val_str, size);
+ else
+ goto error;
+
+ } else if (cgc_push(&args, arg) != 0) {
+ goto error;
+ }
+ }
+
+ val = op->function(&args, &is_bad_formula);
+ if (is_bad_formula)
+ goto error;
+
+ if (cgc_ftoa(val, val_str, size) == NULL)
+ goto error;
+
+ return 0;
+
+error:
+ cgc_clear_stack(&args);
+ return -1;
+}
+
+/*@
+ assigns \result \from \nothing;
+ assigns *is_bad_formula \from \nothing;
+ ensures \initialized(is_bad_formula);
+ */
+static double cgc_eval_formula(char *formula, int *is_bad_formula, stack_t **cir_ref, int id)
+{
+ char val_str[TMP_STR_SIZE];
+ char tmp_id_str[TMP_STR_SIZE];
+ size_t size = TMP_STR_SIZE;
+ double val = 0.0;
+ double result = 0.0;
+ *is_bad_formula = 0;
+ cell_type_e cell_type;
+ char *arg;
+
+ if(cgc_itoa(id, tmp_id_str, size) == NULL)
+ goto error;
+
+ cgc_push_copy(cir_ref, tmp_id_str, strlen(tmp_id_str) + 1);
+ queue_t *rpn = cgc_infixtorpn(formula, strlen(formula) + 1);
+
+ queue_t *args = NULL;
+ stack_t *values = NULL;
+
+ stack_t *tmp = NULL;
+ operator_t *op = NULL;
+
+ while (rpn != NULL) {
+ arg = cgc_dequeue_copy(&rpn);
+ cell_type = cgc_parsearg(arg);
+ switch(cell_type) {
+ case DOUBLE:
+ cgc_push(&values, arg);
+ break;
+ case FUNCTION:
+ op = cgc_get_op(arg);
+ if (cgc_eval_function(op, &values, val_str, size) == -1) {
+ goto error;
+ }
+
+ cgc_push_copy(&values, val_str, size);
+ break;
+ case CELL_ID:
+ tmp = *cir_ref;
+ cell_t *cell = cgc_get_cell(arg);
+ if(cell == NULL)
+ goto error;
+
+ while (tmp != NULL) {
+ if(cgc_itoa(cell->id, tmp_id_str, size) == NULL)
+ goto error;
+
+ if (memcmp(tmp->data, tmp_id_str, strlen(tmp->data) + 1) == 0)
+ goto error; //Circular reference
+ tmp = tmp->next;
+ }
+
+ if (cell->cell_type == UNUSED) {
+ cgc_push_copy(&values, "0", sizeof("0"));
+ } else if (cell->cell_type == DOUBLE) {
+ cgc_push_copy(&values, cell->str, strlen(cell->str) + 1);
+ } else if(cell->cell_type == FORMULA) {
+ val = cgc_eval_formula(cell->formula, is_bad_formula, cir_ref, cell->id);
+ if(*is_bad_formula)
+ goto error;
+
+ cgc_ftoa(val, val_str, size);
+ cgc_push_copy(&values, val_str, size);
+ } else {
+ goto error;
+ }
+
+ break;
+ default:
+ goto error;
+ }
+ }
+
+ char *result_str = cgc_pop_copy(&values);
+ if (values != NULL)
+ goto error;
+
+ result = cgc_atof(result_str, size, is_bad_formula);
+ if (*is_bad_formula)
+ goto error;
+
+ goto cleanup;
+
+error:
+ *is_bad_formula = 1;
+ val = 0.0;
+ cgc_clear_queue(&rpn);
+ cgc_clear_queue(&args);
+ cgc_clear_stack(&values);
+cleanup:
+ free(cgc_pop_copy(cir_ref));
+
+ return result;
+}
+
+static queue_t *cgc_infixtorpn(char *infix, size_t size)
+{
+ /* Use RPN */
+ int is_mismatched = 0;
+ int func_size = 16;
+ int func_idx = -1;
+ char *formula = malloc(size);
+ int *func_args = malloc(func_size * sizeof(int));
+
+ char *delims = "():,+-*/";
+ char *arg, *iter;
+ char delim;
+ char arith_op[2] = {'\0', '\0'};
+ char *value;
+ cell_type_e arg_type;
+ stack_t *operators = NULL;
+ queue_t *output_q = NULL;
+
+ memcpy(formula, infix, size);
+ if (cgc_sanitize_formula(formula, size) != 0)
+ goto cleanup;
+
+ arg = iter = formula;
+ size_t i = 0;
+ char prev_char = 0;
+ while ( i++ < size) {
+ if (strchr(delims, *iter) == NULL && *iter != '\0') {
+ prev_char = *iter;
+ iter++;
+ continue;
+ } else if (strchr(delims, *iter) != NULL) {
+ if (*iter == '-') {
+ if(i <= 1 || (prev_char != ')' && (prev_char < '0' || prev_char > '9'))) {
+ prev_char = *iter;
+ iter++;
+ continue;
+ }
+ }
+ }
+
+ prev_char = *iter;
+ delim = *iter;
+ *iter = '\0';
+ arg_type = cgc_parsearg(arg);
+ switch (arg_type) {
+ case DOUBLE:
+ case CELL_ID:
+ cgc_enqueue_copy(&output_q, arg, strlen(arg) + 1);
+ break;
+ case FUNCTION:
+#ifdef PATCHED
+ if(func_idx == func_size-1) {
+#else
+ if(func_idx == func_size) {
+#endif
+ func_size *= 2;
+ int *temp = realloc(func_args, func_size * sizeof(int));
+ if (temp == NULL)
+ goto error;
+ func_args = temp;
+ }
+
+ func_args[++func_idx] = 0;
+ cgc_push_copy(&operators, arg, strlen(arg) + 1);
+ break;
+ case BAD_CELL:
+ break;
+ default:
+ goto error;
+ }
+
+ is_mismatched = 0;
+ switch(delim) {
+ case '(':
+ cgc_push_copy(&operators, "(", strlen("(") + 1);
+ break;
+ case ')':
+ is_mismatched = 1;
+ while (operators != NULL) {
+ if (strcmp(cgc_peek_top(operators), "(") == 0) {
+ value = cgc_pop_copy(&operators);
+ free(value);
+ is_mismatched = 0;
+ break;
+ } else {
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ }
+ }
+
+ // handle parens without any operator
+ if (cgc_peek_top(operators) == NULL || func_idx < 0)
+ break;
+
+ char num_args_str[16];
+ if(strchr(delims, cgc_peek_top(operators)[0]) != NULL) {
+ break;
+ } else if (cgc_parsearg(cgc_peek_top(operators)) == FUNCTION) {
+ cgc_enqueue_copy(&output_q, cgc_itoa(func_args[func_idx--] + 1, num_args_str,
+ sizeof(num_args_str)), sizeof(num_args_str));
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ }
+
+ break;
+ case ',':
+ is_mismatched = 1;
+ while (operators != NULL) {
+ if (strcmp(cgc_peek_top(operators), "(") == 0) {
+ if (func_idx >= 0)
+ func_args[func_idx]++;
+ is_mismatched = 0;
+ break;
+ } else {
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ }
+ }
+ break;
+ case '+':
+ case '-':
+ //TODO - FIXME - precedence is broken
+ //TODO - FIXME - negative is still broken
+ // 4/5-5
+ arith_op[0] = delim;
+ while (operators != NULL) {
+ if (strcmp(cgc_peek_top(operators), "-") == 0 || strcmp(cgc_peek_top(operators), "+") == 0 ||
+ strcmp(cgc_peek_top(operators), "+") == 0 || strcmp(cgc_peek_top(operators), "/") == 0)
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ else
+ break;
+ }
+
+ cgc_push_copy(&operators, arith_op, strlen(arith_op)+1);
+ break;
+ case '*':
+ case '/':
+ //TODO - FIXME - precedence is broken
+ arith_op[0] = delim;
+ while (operators != NULL) {
+ if (strcmp(cgc_peek_top(operators), "/") == 0 || strcmp(cgc_peek_top(operators), "*") == 0)
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ else
+ break;
+
+ }
+
+ cgc_push_copy(&operators, arith_op, strlen(arith_op)+1);
+ break;
+
+ case '\0':
+ goto finish;
+ default:
+ goto error;
+ }
+
+ if (is_mismatched)
+ goto error;
+
+ arg = ++iter;
+ }
+finish:
+
+ while (operators != NULL) {
+ if (strcmp(cgc_peek_top(operators), "(") == 0 || strcmp(cgc_peek_top(operators), ")") == 0)
+ goto error;
+
+ cgc_enqueue(&output_q, cgc_pop_copy(&operators));
+ }
+
+ goto cleanup;
+
+error:
+ cgc_clear_queue(&output_q);
+ cgc_clear_stack(&operators);
+
+cleanup:
+ free(formula);
+ free(func_args);
+ return output_q;
+}
diff --git a/cgc-challenges/Accel/accelfunc.c b/cgc-challenges/Accel/accelfunc.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce7ef04defe7c303c1b37f44aff78cc03a512897
--- /dev/null
+++ b/cgc-challenges/Accel/accelfunc.c
@@ -0,0 +1,769 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "common.h"
+#include "libcgc.h"
+
+
+
+#include "cgc_accelfunc.h"
+#include "cgc_convert.h"
+
+double cgc_handle_op_avg(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand;
+ char *front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ result += operand;
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ return result / (double) i;
+}
+
+double cgc_handle_op_count(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand;
+ char *front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ result = i;
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ return result;
+}
+
+double cgc_handle_op_max(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ double max = 0.0;
+ if (*args == NULL)
+ goto error;
+
+ double operand;
+ char *front = cgc_pop_copy(args);
+ if (front != NULL) {
+ max = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if (*is_bad_formula)
+ goto error;
+ i++;
+ }
+
+ front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (operand > max)
+ max = operand;
+
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ max = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ return max;
+}
+
+double cgc_handle_op_median(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ stack_t *sorted, *tmp, *prev;
+#ifdef PATCHED
+ sorted = NULL;
+#endif
+ if (*args == NULL)
+ goto error;
+ sorted = NULL;
+
+ double median = 0.0, operand, temp;
+ char *front = cgc_pop_copy(args);
+
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ if(*is_bad_formula) {
+ free(front);
+ goto error;
+ } else {
+ cgc_push(&sorted, front);
+ i++;
+ }
+
+ front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ if(*is_bad_formula)
+ goto error;
+
+ //using stack as linked list
+ tmp = sorted;
+ int passed_first = 0, is_inserted = 0;
+ stack_t *elem = NULL;
+ while (tmp != NULL) {
+ temp = cgc_atof(tmp->data, strlen(tmp->data) + 1, is_bad_formula);
+ if (operand <= temp) {
+ if (!passed_first) {
+ cgc_push(&sorted, front);
+ } else {
+ elem = malloc(sizeof(stack_t));
+ elem->data = front;
+ elem->next = tmp;
+ prev->next = elem;
+ }
+ is_inserted = 1;
+ break;
+ } else {
+ prev = tmp;
+ tmp = tmp->next;
+ passed_first++;
+ }
+ }
+ if (!is_inserted) {
+ tmp = sorted;
+ while (tmp->next != NULL)
+ tmp = tmp->next;
+
+ elem = malloc(sizeof(stack_t));
+ elem->data = front;
+ elem->next = NULL;
+ tmp->next = elem;
+ }
+
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ tmp = sorted;
+ int j = 0;
+ if (i % 2 == 0) {
+ for(j = 0; j < (i / 2) - 1; j++)
+ tmp = tmp->next;
+
+ median += cgc_atof(tmp->data, strlen(tmp->data) + 1, is_bad_formula);
+ tmp = tmp->next;
+ median += cgc_atof(tmp->data, strlen(tmp->data) + 1, is_bad_formula);
+
+ median /= 2;
+ } else {
+ for(j = 0; j < (i / 2); j++)
+ tmp = tmp->next;
+
+ median += cgc_atof(tmp->data, strlen(tmp->data) + 1, is_bad_formula);
+ }
+
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ median = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ cgc_clear_stack(&sorted);
+ return median;
+}
+
+double cgc_handle_op_min(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ double min = 0.0;
+ if (*args == NULL)
+ goto error;
+
+ double operand;
+ char *front = cgc_pop_copy(args);
+ if (front != NULL) {
+ min = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if (*is_bad_formula)
+ goto error;
+ i++;
+ }
+
+ front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (operand < min)
+ min = operand;
+
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ min = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ return min;
+}
+
+double cgc_handle_op_stddev(stack_t **args, int *is_bad_formula)
+{
+ size_t i = 0;
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand, mean = 0.0;
+ stack_t *tmp = *args;
+
+ while (tmp != NULL) {
+ operand = cgc_atof(tmp->data, strlen(tmp->data) + 1, is_bad_formula);
+ if(*is_bad_formula)
+ goto error;
+
+ mean += operand;
+ i++;
+ tmp = tmp->next;
+ }
+ if (i == 0)
+ goto done;
+ mean /= i;
+
+ i = 0;
+ char *front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+
+ //TODO - Look into this, I don't know why pow is failing
+ //result += (pow((operand - mean), 2.0));
+ result += ((operand - mean) * (operand - mean));
+ front = cgc_pop_copy(args);
+ i++;
+ }
+
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ if (i == 0) {
+ i = 1;
+ goto error;
+ }
+ return sqrt(result / (double) i);
+}
+
+double cgc_handle_op_abs(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = fabs(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_add(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1, operand2;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ // Get second operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand2 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = operand1 + operand2;
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_cos(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = cos(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_ln(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ if (operand1 == 0)
+ goto error;
+
+ result = log(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_log10(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ if (operand1 == 0)
+ goto error;
+
+ result = log10(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_power(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1, operand2;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ // Get second operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand2 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ if (operand2 == 0.0)
+ result = 1.0;
+ else if (operand2 == 1.0)
+ result = operand1;
+ else if (isnan(operand2))
+ result = operand2;
+ else if (operand1 == 0 && operand2 > 0)
+ result = 0.0;
+ else if (operand1 < 0 && remainder(operand2, 1) == 0.0)
+ result = pow(-operand1, operand2) * (remainder(operand2, 2) == 0 ? 1 : -1);
+ else
+ result = pow(operand1, operand2);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_product(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1, operand2;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ // Get second operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand2 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = operand1 * operand2;
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_quotient(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1, operand2;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ // Get second operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand2 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ if (operand2 == 0)
+ goto error;
+
+ result = operand1 / operand2;
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_sin(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = sin(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_sqrt(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ if (operand1 < 0)
+ goto error;
+
+ result = sqrt(operand1);
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_subtract(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand1, operand2;
+ char *front;
+
+ // Get first operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand1 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ // Get second operand
+ front = cgc_pop_copy(args);
+ if (front == NULL)
+ goto error;
+ operand2 = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ if (*args != NULL)
+ goto error; // Too many arguments
+
+ result = operand1 - operand2;
+ goto done;
+
+error:
+ cgc_clear_stack(args);
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
+
+double cgc_handle_op_sum(stack_t **args, int *is_bad_formula)
+{
+ if (*args == NULL)
+ goto error;
+
+ double result = 0.0, operand;
+ char *front = cgc_pop_copy(args);
+ while(front != NULL) {
+ operand = cgc_atof(front, strlen(front) + 1, is_bad_formula);
+ free(front);
+ if(*is_bad_formula)
+ goto error;
+
+ result += operand;
+ front = cgc_pop_copy(args);
+ }
+
+ goto done;
+
+error:
+ *is_bad_formula = 1;
+ result = 0.0;
+done:
+ return result;
+}
diff --git a/cgc-challenges/Accel/accelio.c b/cgc-challenges/Accel/accelio.c
new file mode 100644
index 0000000000000000000000000000000000000000..45c588c807fe8e915b3f7cd143f177122e1aa7b2
--- /dev/null
+++ b/cgc-challenges/Accel/accelio.c
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+
+
+#include "common.h"
+#include "cgc_accelio.h"
+
+/* sides = 1, trim front
+ * sides = 2, trim back
+ * sides = 3, trim both
+*/
+int cgc_strtrim(char *str, size_t size, int sides)
+{
+ int i, len;
+ len = strlen(str) + 1;
+ if (len > size)
+ return -1;
+ else if (len == 1)
+ return 0;
+
+ if (sides == TRIM_FRONT || sides == TRIM_ALL) {
+ char *tmp = str;
+ for (i = 0; i < len; i++, tmp++) {
+ if (strchr(WHITESPACE, *tmp) == NULL) {
+ memcpy(str, tmp, len - i);
+ break;
+ }
+ }
+ }
+
+ if ((sides == TRIM_BACK || sides == TRIM_ALL) && (len - 1 != 0)) {
+ for (i = len - 2; i >= 0 ; i--) {
+ if (strchr(WHITESPACE, str[i]) == NULL) {
+ str[i + 1] = '\0';
+ break;
+ } else if (i == 0) {
+ str[i] = '\0';
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
+//row and col must be buffers of at least len 4
+int cgc_valid_cell_id(char *input)
+{
+ if (strlen(input) < 2)
+ return -1;
+
+ size_t i = 0, is_num = 0;
+ char row[3];
+ char col[3];
+ char delim = '\0';
+ char c = toupper(input[0]);
+ if (c < 'A' || c > 'Z')
+ return -1;
+ row[0] = c;
+
+ c = toupper(input[1]);
+ if (!(c >= 'A' && c <= 'Z') && !(c >= '0' && c <= '9' ))
+ return -1;
+
+ if (c >= '0' && c <= '9') {
+ col[is_num++] = c;
+ row[1] = '\0';
+ } else {
+ row[1] = c;
+ row[2] = '\0';
+ }
+
+ for (i = 2; i < 5; i++) {
+ if (input[i] == delim && is_num) {
+ col[is_num] = '\0';
+ return 0;
+ }
+ if (input[i] >= '0' && input[i] <= '9' && is_num < 2) {
+ col[is_num++] = input[i];
+ }
+ else {
+ return -1;
+ }
+ }
+
+ return -1;
+}
+
+//row and col must be buffers of at least len 4
+int cgc_get_rowcol(char *input, char *row, char *col, char delim)
+{
+ if (strlen(input) < 2)
+ return -1;
+
+ size_t i = 0, is_num = 0;
+ char c = toupper(input[0]);
+ if (c < 'A' || c > 'Z')
+ return -1;
+ row[0] = c;
+
+ c = toupper(input[1]);
+ if (!(c >= 'A' && c <= 'Z') && !(c >= '0' && c <= '9' ))
+ return -1;
+
+ if (c >= '0' && c <= '9') {
+ col[is_num++] = c;
+ row[1] = '\0';
+ } else {
+ row[1] = c;
+ row[2] = '\0';
+ }
+
+ for (i = 2; i < 5; i++) {
+ if (input[i] == delim && is_num) {
+ col[is_num] = '\0';
+ return 0;
+ }
+ if (input[i] >= '0' && input[i] <= '9' && is_num < 2) {
+ col[is_num++] = input[i];
+ }
+ else {
+ return -1;
+ }
+ }
+
+ return -1;
+}
+
+int cgc_sanitize_formula(char *formula, size_t size)
+{
+ size_t i, j, len;
+ len = strlen(formula);
+ if (len > size)
+ return -1;
+
+ char *sanitized = calloc(1, size);
+ if (sanitized == NULL)
+ return -1;
+
+
+ for (i = 0, j=0; i < len; i++) {
+ if (strchr(WHITESPACE, formula[i]) == NULL)
+ sanitized[j++] = formula[i];
+ }
+ memcpy(formula, sanitized, size);
+ free(sanitized);
+ return 0;
+}
+
diff --git a/cgc-challenges/Accel/atof.c b/cgc-challenges/Accel/atof.c
new file mode 100644
index 0000000000000000000000000000000000000000..166fa42192b643c825f728bd8a8b6ecc6ee89c9e
--- /dev/null
+++ b/cgc-challenges/Accel/atof.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+
+
+
+#include "cgc_convert.h"
+
+double cgc_atof(char *str, size_t size, int *bad_conversion)
+{
+ if (str == NULL || strlen(str) >= size || strlen(str) == 0)
+ goto error;
+
+ double val = 0.0, exp = 0.0, dec_multiplier = 1.0;
+ int has_period = 0, has_exp = 0;
+ int negative = 1;
+ int num_dec = 0;
+
+ if (*str == '-') {
+ str++;
+ if (*str == '\0')
+ goto error;
+ negative = -1;
+ }
+
+ while (*str != '\0') {
+ if (*str >= '0' && *str <= '9') {
+ if (has_exp) {
+ exp = (exp * 10) + (*str - '0');
+ } else if (!has_period) {
+ val = (val * 10) + (*str - '0');
+ } else {
+ dec_multiplier *= 10;
+ num_dec++;
+ val += ((*str - '0') / dec_multiplier);
+ }
+ } else if (*str == '.') {
+ has_period++;
+ } else if (tolower(*str) == 'e') {
+ has_exp++;
+ } else {
+ goto error;
+ }
+
+ if (has_period > 1 || has_exp > 1)
+ goto error;
+
+ if (num_dec >= MAX_DEC)
+ goto done;
+
+ str++;
+ }
+ goto done;
+
+error:
+ *bad_conversion = 1;
+ return 0.0;
+
+done:
+ if (has_exp)
+ val *= pow(10, exp);
+
+ return val * negative;
+}
+
diff --git a/cgc-challenges/Accel/cgc_accel.h b/cgc-challenges/Accel/cgc_accel.h
new file mode 100644
index 0000000000000000000000000000000000000000..1bd2118cf79c246e5ebf5a725bff990f5cb5e8b2
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_accel.h
@@ -0,0 +1,10 @@
+#ifndef ACCEL_H_
+#define ACCEL_H_
+
+int cgc_init_sheet();
+char *cgc_show_cell(char *cell_id, int is_repr, char* val_str, size_t size);
+int cgc_set_cell(char *cell_id, char *cell_str, size_t size);
+int cgc_clear_cell(char *cell_id);
+void cgc_print_assigned_cells();
+
+#endif /* ACCELL_H */
diff --git a/cgc-challenges/Accel/cgc_accelfunc.h b/cgc-challenges/Accel/cgc_accelfunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a74d62ce9fb1583911d1a41a78a4b8fcc9a3ae5
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_accelfunc.h
@@ -0,0 +1,32 @@
+#include "cgc_stack.h"
+
+#ifndef ACCELFUNC_H_
+#define ACCELFUNC_H_
+
+typedef double (*handle_op_t)(stack_t **args, int *is_bad_formula);
+
+typedef struct {
+ const char *name;
+ handle_op_t function;
+} operator_t;
+
+double cgc_handle_op_avg(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_count(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_max(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_median(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_min(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_stddev(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_abs(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_add(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_cos(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_ln(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_log10(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_power(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_product(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_quotient(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_sin(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_sqrt(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_subtract(stack_t **args, int *is_bad_formula);
+double cgc_handle_op_sum(stack_t **args, int *is_bad_formula);
+
+#endif /* ACCELFUNC_H */
diff --git a/cgc-challenges/Accel/cgc_accelio.h b/cgc-challenges/Accel/cgc_accelio.h
new file mode 100644
index 0000000000000000000000000000000000000000..2eb238c2d38cc9a10911bb020be4cfeaa153d1c3
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_accelio.h
@@ -0,0 +1,16 @@
+#ifndef ACCELIO_H_
+#define ACCELIO_H_
+
+#define TRIM_FRONT 1
+#define TRIM_BACK 2
+#define TRIM_ALL 3
+#define WHITESPACE "\r\n\t "
+
+#include "common.h"
+
+int cgc_strtrim(char *str, size_t size, int sides);
+int cgc_valid_cell_id(char *input);
+int cgc_get_rowcol(char *input, char *row, char *col, char delim);
+int cgc_sanitize_formula(char *formula, size_t size);
+
+#endif /* ACCELIO_H */
diff --git a/cgc-challenges/Accel/cgc_convert.h b/cgc-challenges/Accel/cgc_convert.h
new file mode 100644
index 0000000000000000000000000000000000000000..83c0dcb29c0623f720365ecd7c882c19b5434f36
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_convert.h
@@ -0,0 +1,12 @@
+#ifndef CONVERT_H_
+#define CONVERT_H_
+
+#define MAX_DEC 5
+
+#include "common.h"
+
+extern char *cgc_itoa(int value, char *str, size_t size);
+extern char *cgc_ftoa(double value, char *str, size_t size);
+extern double cgc_atof(char *str, size_t size, int *bad_conversion);
+
+#endif /* CONVERT_H */
diff --git a/cgc-challenges/Accel/cgc_queue.h b/cgc-challenges/Accel/cgc_queue.h
new file mode 100644
index 0000000000000000000000000000000000000000..9481c793cbd46f94b3c7de290aa7ad19f97a0bac
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_queue.h
@@ -0,0 +1,18 @@
+#ifndef QUEUE_H_
+#define QUEUE_H_
+
+#include "common.h"
+
+typedef struct queue queue_t;
+struct queue {
+ char *data;
+ queue_t *next;
+};
+
+char *cgc_peek_front(queue_t *queue);
+int cgc_enqueue(queue_t **queue, char *data);
+int cgc_enqueue_copy(queue_t **queue, char *data, size_t size);
+char *cgc_dequeue_copy(queue_t **queue);
+void cgc_clear_queue(queue_t **queue);
+
+#endif /* QUEUE_H */
diff --git a/cgc-challenges/Accel/cgc_stack.h b/cgc-challenges/Accel/cgc_stack.h
new file mode 100644
index 0000000000000000000000000000000000000000..e04bf52ceee8fd4dcec2bd7f888f7cdcaf72d983
--- /dev/null
+++ b/cgc-challenges/Accel/cgc_stack.h
@@ -0,0 +1,18 @@
+#ifndef STACK_H_
+#define STACK_H_
+
+#include "common.h"
+
+typedef struct stack stack_t;
+struct stack {
+ char *data;
+ stack_t *next;
+};
+
+char *cgc_peek_top(stack_t *stack);
+int cgc_push(stack_t **stack, char *data);
+int cgc_push_copy(stack_t **stack, char *data, size_t size);
+char *cgc_pop_copy(stack_t **stack);
+void cgc_clear_stack();
+
+#endif /* STACK_H */
diff --git a/cgc-challenges/Accel/ftoa.c b/cgc-challenges/Accel/ftoa.c
new file mode 100644
index 0000000000000000000000000000000000000000..495671085c99d9f0abf1aa8df00c29b97dd7c830
--- /dev/null
+++ b/cgc-challenges/Accel/ftoa.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "common.h"
+#include "libcgc.h"
+
+
+
+#include "cgc_convert.h"
+
+char *cgc_ftoa(double value, char *str, size_t size) {
+ if (size <= 1)
+ return NULL;
+
+ if (isinf(value) || isnan(value))
+ return NULL;
+
+ size_t i = 0;
+ int negative = 0;
+
+ if (value < 0) {
+ negative = 1;
+ str[i++] = '-';
+ value *= -1;
+ }
+
+ if (i == size)
+ return NULL;
+
+ // apply rounding
+ double rem = remainder(value, 0.001) * pow(10, 4);
+ if (rem > 5 || (rem < 0 && rem > -5))
+ if (!negative)
+ value += 0.0005;
+ else
+ if (negative)
+ value += 0.0005;
+ int magnitude = value == 0 ? 0 : log10(value);
+ if (magnitude < 0)
+ magnitude = 0;
+ for (; magnitude > -4; magnitude--)
+ {
+ if (i == size)
+ break;
+
+ if (magnitude == -1)
+ {
+ str[i++] = '.';
+ if (i == size)
+ break;
+ }
+
+ double e = pow(10, magnitude);
+ int digit = value / e;
+ value -= digit * e;
+ str[i++] = digit + '0';
+ }
+
+ if (i == size)
+ return NULL;
+ else
+ str[i] = '\0';
+
+ return str;
+}
diff --git a/cgc-challenges/Accel/itoa.c b/cgc-challenges/Accel/itoa.c
new file mode 100644
index 0000000000000000000000000000000000000000..56566b05704467c8fd746fb63ebbb83efaa049f5
--- /dev/null
+++ b/cgc-challenges/Accel/itoa.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "libcgc.h"
+
+
+
+#include "cgc_convert.h"
+
+char *cgc_itoa(int value, char *str, size_t size)
+{
+ int base = 10;
+ if (size <= 1 )
+ return NULL;
+
+ size_t i = 0;
+ int is_negative = 0;
+
+ if (value < 0)
+ is_negative = 1;
+
+ do {
+ if (is_negative)
+ str[i++] = '0' - value % base;
+ else
+ str[i++] = '0' + value % base;
+
+ value /= base;
+ } while (i < size - 1 && value != 0);
+
+ if (value != 0 || (i == size - 1 && is_negative))
+ return NULL;
+
+ if (is_negative)
+ str[i++] = '-';
+ str[i--] = '\0';
+
+ int j = 0;
+ while (i > j) {
+ char c = str[j];
+ str[j++] = str[i];
+ str[i--] = c;
+ }
+
+ return str;
+}
diff --git a/cgc-challenges/Accel/lib/calloc.c b/cgc-challenges/Accel/lib/calloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f90fdc1cdd61b33aa790f867b421365e6dac43a
--- /dev/null
+++ b/cgc-challenges/Accel/lib/calloc.c
@@ -0,0 +1,46 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_stdlib.h"
+#include "cgc_string.h"
+
+void *cgc_calloc(cgc_size_t nmemb, cgc_size_t size)
+{
+ if (nmemb == 0 || size == 0)
+ return NULL;
+
+ cgc_size_t tot = nmemb * size;
+
+ // Overflow
+ if (tot / size != nmemb)
+ return NULL;
+
+ void *ptr = cgc_malloc(tot);
+ if (ptr == NULL)
+ return NULL;
+
+ return cgc_memset(ptr, 0, tot);
+}
diff --git a/cgc-challenges/Accel/lib/cgc_ctype.h b/cgc-challenges/Accel/lib/cgc_ctype.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0f04001d7f12c141b522af47fb79fd3affa1c48
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_ctype.h
@@ -0,0 +1,16 @@
+#ifndef CTYPE_H_
+#define CTYPE_H_
+
+int cgc_isdigit(int c);
+int cgc_isascii(int c);
+int cgc_isprint(int c);
+int cgc_isalnum(int c);
+int cgc_isalpha(int c);
+int cgc_islower(int c);
+int cgc_isupper(int c);
+int cgc_isspace(int c);
+int cgc_ispunct(int c);
+int cgc_tolower(int c);
+int cgc_toupper(int c);
+
+#endif /* !CTYPE_H_ */
diff --git a/cgc-challenges/Accel/lib/cgc_malloc.h b/cgc-challenges/Accel/lib/cgc_malloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..22353bc714271128e3c54ccd420abf3031f7ada5
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_malloc.h
@@ -0,0 +1,53 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#ifndef MALLOC_COMMON_H
+#define MALLOC_COMMON_H
+
+#include "cgc_stdint.h"
+
+#define NUM_FREE_LISTS 32
+#define HEADER_PADDING 24
+#define NEW_CHUNK_SIZE 262144
+#define ALIGNMENT 8
+
+extern struct blk_t *cgc_free_lists[NUM_FREE_LISTS];
+extern cgc_size_t size_class_limits[NUM_FREE_LISTS];
+
+struct blk_t {
+ cgc_size_t size;
+ unsigned int free;
+ struct blk_t *fsucc;
+ struct blk_t *fpred;
+ struct blk_t *next;
+ struct blk_t *prev;
+};
+
+void cgc_coalesce(struct blk_t *);
+int cgc_get_size_class(cgc_size_t size);
+void cgc_insert_into_flist(struct blk_t *blk);
+void cgc_remove_from_flist(struct blk_t *blk);
+
+#endif /* MALLOC_COMMON_H */
diff --git a/cgc-challenges/Accel/lib/cgc_stdarg.h b/cgc-challenges/Accel/lib/cgc_stdarg.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f66d4681bf1a172da384a9262280762c14109c8
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_stdarg.h
@@ -0,0 +1,15 @@
+#ifndef STDARG_H_
+#define STDARG_H_
+
+#ifdef WIN
+#include <stdarg.h>
+#else
+typedef __builtin_va_list __gnuc_va_list;
+#define va_start(v,l) __builtin_va_start(v,l)
+#define va_end(v) __builtin_va_end(v)
+#define va_arg(v,l) __builtin_va_arg(v,l)
+
+typedef __gnuc_va_list va_list;
+#endif
+
+#endif /* !STDARG_H_ */
diff --git a/cgc-challenges/Accel/lib/cgc_stddef.h b/cgc-challenges/Accel/lib/cgc_stddef.h
new file mode 100644
index 0000000000000000000000000000000000000000..56c1ea51de23b5bc3e8416ea79c285e244e0b22f
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_stddef.h
@@ -0,0 +1,17 @@
+#ifndef STDDEF_H_
+#define STDDEF_H_
+
+#define PAGE_SIZE 4096
+
+typedef long int ptrdiff_t;
+
+#ifndef _LIBCGC_H
+ typedef long unsigned int cgc_size_t;
+ typedef long int cgc_ssize_t;
+
+ #define NULL 0
+#endif
+
+#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)
+
+#endif /* !STDDEF_H_ */
diff --git a/cgc-challenges/Accel/lib/cgc_stdint.h b/cgc-challenges/Accel/lib/cgc_stdint.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbb43053af6aa359efc77129b12461badd72ebd2
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_stdint.h
@@ -0,0 +1,38 @@
+#ifndef STDINT_H_
+#define STDINT_H_
+
+typedef signed char int8_t;
+typedef short int int16_t;
+typedef int int32_t;
+typedef long long int int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long int uint64_t;
+
+typedef int intptr_t;
+typedef unsigned int uintptr_t;
+
+# define __INT64_C(c) c ## LL
+# define __UINT64_C(c) c ## ULL
+/* Limits of integral types. */
+
+/* Minimum of signed integral types. */
+# define INT8_MIN (-128)
+# define INT16_MIN (-32767-1)
+# define INT32_MIN (-2147483647-1)
+# define INT64_MIN (-__INT64_C(9223372036854775807)-1)
+/* Maximum of signed integral types. */
+# define INT8_MAX (127)
+# define INT16_MAX (32767)
+# define INT32_MAX (2147483647)
+# define INT64_MAX (__INT64_C(9223372036854775807))
+
+/* Maximum of unsigned integral types. */
+# define UINT8_MAX (255)
+# define UINT16_MAX (65535)
+# define UINT32_MAX (4294967295U)
+# define UINT64_MAX (__UINT64_C(18446744073709551615))
+
+#endif /* !STDINT_H_ */
diff --git a/cgc-challenges/Accel/lib/cgc_stdlib.h b/cgc-challenges/Accel/lib/cgc_stdlib.h
new file mode 100644
index 0000000000000000000000000000000000000000..2914bc540adb26c17b37f148dccc6c144b3d404d
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_stdlib.h
@@ -0,0 +1,28 @@
+#ifndef STDLIB_H_
+#define STDLIB_H_
+
+#include "libcgc.h"
+#include "cgc_stdarg.h"
+#include "cgc_stddef.h"
+
+#define isinf(x) __builtin_isinf(x)
+#define isnan(x) __builtin_isnan(x)
+
+extern int cgc_printf(const char *fmt, ...);
+extern int cgc_sprintf(char *s, const char *fmt, ...);
+
+long cgc_strtol(const char *str, char **endptr, int base);
+unsigned long strtoul(const char *str, char **endptr, int base);
+
+extern void *cgc_malloc(cgc_size_t size);
+extern void *cgc_calloc(cgc_size_t nmemb, cgc_size_t size);
+extern void *cgc_realloc(void *ptr, cgc_size_t size);
+extern void cgc_free(void *ptr);
+extern cgc_size_t malloc_size(void *ptr);
+
+static void cgc_exit(int ret)
+{
+ cgc__terminate(ret);
+}
+
+#endif /* !STDLIB_H_ */
diff --git a/cgc-challenges/Accel/lib/cgc_string.h b/cgc-challenges/Accel/lib/cgc_string.h
new file mode 100644
index 0000000000000000000000000000000000000000..535e811a73ef30387fae2ac291c889980fed9fcf
--- /dev/null
+++ b/cgc-challenges/Accel/lib/cgc_string.h
@@ -0,0 +1,18 @@
+#ifndef STRING_H_
+#define STRING_H_
+
+#include "cgc_stddef.h"
+
+extern void *cgc_memcpy(void *dest, const void *src, cgc_size_t n);
+extern void *cgc_memmove(void *dest, const void *src, cgc_size_t n);
+extern void *cgc_memset(void *dest, int c, cgc_size_t n);
+extern int cgc_memcmp(void *s1, const void *s2, cgc_size_t n);
+extern void *memchr(const void *s, int c, cgc_size_t n);
+
+extern cgc_size_t cgc_strlen(const char *s);
+extern char *cgc_strcpy(char *dest, const char *src);
+extern char *strncpy(char *dest, const char *src, cgc_size_t n);
+extern char *cgc_strchr(const char *s, int c);
+extern char *cgc_strsep(char **stringp, const char *delim);
+
+#endif /* !STRING_H_ */
diff --git a/cgc-challenges/Accel/lib/ctype.c b/cgc-challenges/Accel/lib/ctype.c
new file mode 100644
index 0000000000000000000000000000000000000000..abbcdaf79ff39bbd12928272a330def6c78d6fd0
--- /dev/null
+++ b/cgc-challenges/Accel/lib/ctype.c
@@ -0,0 +1,143 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "cgc_ctype.h"
+
+#define NUM_ASCII_CHAR 128
+#define ASCII_MASK 0x7F
+
+// SPACE is first printable
+#define SPACE 0x20
+
+// DEL is only char after SPACE that is CNTRL
+#define DEL 0x7F
+
+static const unsigned char _punct[NUM_ASCII_CHAR] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0
+};
+
+static const unsigned char _xdigit[NUM_ASCII_CHAR] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+int cgc_isalnum(int c)
+{
+ return cgc_isalpha(c) || cgc_isdigit(c);
+}
+
+int cgc_isalpha(int c)
+{
+ return cgc_islower(c) || cgc_isupper(c);
+}
+
+int cgc_isascii(int c)
+{
+ return !(c & ~ASCII_MASK);
+}
+
+int cgc_isblank(int c)
+{
+ return (c == ' ' || c == '\t');
+}
+
+int cgc_iscntrl(int c)
+{
+ return c == DEL || c < SPACE;
+}
+
+int cgc_isdigit(int c)
+{
+ return (unsigned int ) c - '0' < 10;
+}
+
+int cgc_isgraph(int c)
+{
+ return c != ' ' && cgc_isprint(c);
+}
+
+int cgc_islower(int c)
+{
+ return (unsigned int) c - 'a' < 26;
+}
+
+int cgc_isprint(int c)
+{
+ return c >= SPACE && c != DEL;
+}
+
+int cgc_ispunct(int c)
+{
+ return _punct[c];
+}
+
+int cgc_isspace(int c)
+{
+ return (c > 8 && c < 14) || c == ' ';
+}
+
+int cgc_isupper(int c)
+{
+ return (unsigned int ) c - 'A' < 26;
+}
+
+int cgc_isxdigit(int c)
+{
+ return _xdigit[c];
+}
+
+int cgc_toascii(int c)
+{
+ return c & ASCII_MASK;
+}
+
+int cgc_tolower(int c)
+{
+ if (cgc_isupper(c))
+ return c | SPACE;
+
+ return c;
+}
+
+int cgc_toupper(int c)
+{
+ if (cgc_islower(c))
+ return c & (~SPACE & ASCII_MASK);
+
+ return c;
+}
diff --git a/cgc-challenges/Accel/lib/free.c b/cgc-challenges/Accel/lib/free.c
new file mode 100644
index 0000000000000000000000000000000000000000..cdc1c230e377f8b532cbc5ba29aeb06a6e508dbd
--- /dev/null
+++ b/cgc-challenges/Accel/lib/free.c
@@ -0,0 +1,51 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_malloc.h"
+#include "cgc_stdlib.h"
+
+static void cgc_free_huge(struct blk_t *blk)
+{
+ cgc_deallocate(blk, blk->size);
+}
+
+void cgc_free(void *ptr)
+{
+ if (ptr == NULL)
+ return;
+
+ struct blk_t *blk = (struct blk_t *)((intptr_t)ptr - HEADER_PADDING);
+
+ if (blk->free != 0)
+ return;
+
+ if (blk->size >= NEW_CHUNK_SIZE) {
+ cgc_free_huge(blk);
+ } else {
+ cgc_insert_into_flist(blk);
+ cgc_coalesce(blk);
+ }
+}
diff --git a/cgc-challenges/Accel/lib/malloc.c b/cgc-challenges/Accel/lib/malloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..e68c0104d446af5b66d5ec011c8d35ebf7e292a3
--- /dev/null
+++ b/cgc-challenges/Accel/lib/malloc.c
@@ -0,0 +1,143 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_malloc.h"
+#include "cgc_stdlib.h"
+
+/* Get some more memory through allocate */
+static int cgc_allocate_new_blk(void)
+{
+ void *ret;
+ struct blk_t *new_blk;
+ cgc_size_t size = NEW_CHUNK_SIZE;
+
+ if (cgc_allocate(size, 0, &ret) != 0) {
+ return 1;
+ }
+
+ if (ret == NULL)
+ return 1;
+
+ new_blk = (struct blk_t *)ret;
+ new_blk->size = size;
+ new_blk->free = 1;
+ new_blk->fpred = NULL;
+ new_blk->fsucc = NULL;
+ new_blk->prev = NULL;
+ new_blk->next = NULL;
+
+ cgc_insert_into_flist(new_blk);
+ return 0;
+}
+
+/* Find first fit block for a size */
+static int cgc_find_fit(cgc_size_t size, struct blk_t **blk)
+{
+ int sc_i = cgc_get_size_class(size);
+
+ for (; sc_i < NUM_FREE_LISTS; sc_i++) {
+ *blk = cgc_free_lists[sc_i];
+ for(; *blk != NULL; *blk = (*blk)->fsucc)
+ if ((*blk)->size >= size)
+ return sc_i;
+ }
+
+ *blk = NULL;
+ return -1;
+}
+
+static void *cgc_malloc_huge(cgc_size_t size)
+{
+ void *mem;
+ size += HEADER_PADDING;
+ if (cgc_allocate(size, 0, &mem) != 0)
+ return NULL;
+ struct blk_t *blk = mem;
+ blk->size = size;
+ blk->free = 0;
+ blk->fpred = NULL;
+ blk->fsucc = NULL;
+ blk->prev = NULL;
+ blk->next = NULL;
+ return (void *)((intptr_t)blk + HEADER_PADDING);
+}
+
+void *cgc_malloc(cgc_size_t size)
+{
+ if (size == 0)
+ return NULL;
+
+ if (size + HEADER_PADDING >= NEW_CHUNK_SIZE)
+ return cgc_malloc_huge(size);
+
+ if (size % ALIGNMENT != 0)
+ size = (size + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
+
+ if (size >= 0x80000000)
+ return NULL;
+ size += HEADER_PADDING;
+
+ struct blk_t *blk = NULL;
+ int sc_i = cgc_find_fit(size, &blk);
+
+ /* Allocate a new block if no fit */
+ if (blk == NULL) {
+ if (cgc_allocate_new_blk() != 0) {
+ return NULL;
+ } else {
+ sc_i = NUM_FREE_LISTS - 1;
+ blk = cgc_free_lists[sc_i];
+ }
+ }
+
+ /* Remove the block we're going to use from the free list */
+ cgc_remove_from_flist(blk);
+
+ /* Split the block into two pieces if possible */
+ cgc_size_t sdiff = blk->size - size;
+ if (sdiff > 2 * HEADER_PADDING) {
+ struct blk_t *nb = (struct blk_t *)((intptr_t)blk + size);
+
+ nb->size = sdiff;
+ nb->free = 1;
+ nb->fsucc = NULL;
+ nb->fpred = NULL;
+
+ blk->size = size;
+
+ /* Patch up blk list pointers */
+ nb->prev = blk;
+ nb->next = blk->next;
+ if (blk->next)
+ blk->next->prev = nb;
+ blk->next = nb;
+
+ /* Put the new block into the free list */
+ cgc_insert_into_flist(nb);
+ }
+
+ return (void *)((intptr_t)blk + HEADER_PADDING);
+}
diff --git a/cgc-challenges/Accel/lib/malloc_common.c b/cgc-challenges/Accel/lib/malloc_common.c
new file mode 100644
index 0000000000000000000000000000000000000000..79acf0e5a32fc33c873bfc34be04bd1196ffa271
--- /dev/null
+++ b/cgc-challenges/Accel/lib/malloc_common.c
@@ -0,0 +1,127 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_malloc.h"
+#include "cgc_stdlib.h"
+
+cgc_size_t size_class_limits[NUM_FREE_LISTS] = {
+ 2, 3, 4, 8,
+ 16, 24, 32, 48,
+ 64, 96, 128, 192,
+ 256, 384, 512, 768,
+ 1024, 1536, 2048, 3072,
+ 4096, 6144, 8192, 12288,
+ 16384, 24576, 32768, 49152,
+ 65536, 98304, 131072, INT32_MAX
+};
+
+struct blk_t *cgc_free_lists[NUM_FREE_LISTS] = {0};
+
+static void cgc_remove_from_blist(struct blk_t *blk)
+{
+ if (blk->prev)
+ blk->prev->next = blk->next;
+
+ if (blk->next)
+ blk->next->prev = blk->prev;
+}
+
+int cgc_get_size_class(cgc_size_t size)
+{
+ int i;
+ for (i = 0; i < NUM_FREE_LISTS && size > size_class_limits[i]; i++);
+ return i;
+}
+
+
+void cgc_insert_into_flist(struct blk_t *blk)
+{
+ int sc_i = cgc_get_size_class(blk->size);
+ blk->free = 1;
+
+ if (cgc_free_lists[sc_i] == NULL) {
+ cgc_free_lists[sc_i] = blk;
+ return;
+ }
+
+ blk->fsucc = cgc_free_lists[sc_i];
+ cgc_free_lists[sc_i]->fpred = blk;
+ cgc_free_lists[sc_i] = blk;
+ blk->fpred = NULL;
+}
+
+void cgc_remove_from_flist(struct blk_t *blk)
+{
+ int sc_i = cgc_get_size_class(blk->size);
+
+ if (blk->fpred)
+ blk->fpred->fsucc = blk->fsucc;
+
+ if (blk->fsucc)
+ blk->fsucc->fpred = blk->fpred;
+
+ if (cgc_free_lists[sc_i] == blk)
+ cgc_free_lists[sc_i] = blk->fsucc;
+
+ blk->fsucc = NULL;
+ blk->fpred = NULL;
+ blk->free = 0;
+}
+
+void cgc_coalesce(struct blk_t *blk)
+{
+ /* prev and next are free */
+ if (blk->prev && blk->prev->free && blk->next && blk->next->free) {
+ cgc_remove_from_flist(blk->prev);
+ cgc_remove_from_flist(blk->next);
+ cgc_remove_from_flist(blk);
+
+ blk->prev->size += blk->size;
+ blk->prev->size += blk->next->size;
+ cgc_insert_into_flist(blk->prev);
+
+ cgc_remove_from_blist(blk->next);
+ cgc_remove_from_blist(blk);
+ /* Just prev is free */
+ } else if (blk->prev && blk->prev->free && blk->next && !blk->next->free) {
+ cgc_remove_from_flist(blk->prev);
+ cgc_remove_from_flist(blk);
+
+ blk->prev->size += blk->size;
+ cgc_insert_into_flist(blk->prev);
+
+ cgc_remove_from_blist(blk);
+ /* Just next is free */
+ } else if (blk->prev && !blk->prev->free && blk->next && blk->next->free) {
+ cgc_remove_from_flist(blk->next);
+ cgc_remove_from_flist(blk);
+
+ blk->size += blk->next->size;
+ cgc_insert_into_flist(blk);
+
+ cgc_remove_from_blist(blk->next);
+ }
+}
diff --git a/cgc-challenges/Accel/lib/memchr.c b/cgc-challenges/Accel/lib/memchr.c
new file mode 100644
index 0000000000000000000000000000000000000000..2764e25e16c28dd42729da58aca8da0b9bf68f28
--- /dev/null
+++ b/cgc-challenges/Accel/lib/memchr.c
@@ -0,0 +1,39 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_stdint.h"
+
+extern void *cgc_memchr(const void *s, int c, cgc_size_t n)
+{
+ cgc_size_t i = 0;
+ while (i < n) {
+ if (*((uint8_t *)s + i) == c)
+ return (void *)((intptr_t)s + i);
+
+ i++;
+ }
+ return NULL;
+}
diff --git a/cgc-challenges/Accel/lib/memcmp.c b/cgc-challenges/Accel/lib/memcmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..485a6b319ba4d58376cdb1f93ea9bab0ad829ee9
--- /dev/null
+++ b/cgc-challenges/Accel/lib/memcmp.c
@@ -0,0 +1,36 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "libcgc.h"
+
+int cgc_memcmp(const char *s1, const char *s2, cgc_size_t n)
+{
+ cgc_size_t i;
+ for(i = 0; i < n; i++)
+ if (*s1 != *s2)
+ return *s2 - *s1;
+ else
+ s1++, s2++;
+ return 0;
+}
diff --git a/cgc-challenges/Accel/lib/memcpy.c b/cgc-challenges/Accel/lib/memcpy.c
new file mode 100755
index 0000000000000000000000000000000000000000..3c311d6d4d0d5c179ad1ecddbf02dcfaa256f062
--- /dev/null
+++ b/cgc-challenges/Accel/lib/memcpy.c
@@ -0,0 +1,38 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "cgc_string.h"
+
+void *cgc_memcpy(void *dest, const void *src, cgc_size_t n)
+{
+ unsigned char *d = (unsigned char *)dest, *s = (unsigned char *)src;
+ cgc_size_t i = 0;
+ while (i < n) {
+ d[i] = s[i];
+ i++;
+ }
+
+ return dest;
+}
diff --git a/cgc-challenges/Accel/lib/memset.c b/cgc-challenges/Accel/lib/memset.c
new file mode 100755
index 0000000000000000000000000000000000000000..2c38b2a142eb536af87cea9c18ef7089e1da912c
--- /dev/null
+++ b/cgc-challenges/Accel/lib/memset.c
@@ -0,0 +1,42 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+
+void *cgc_memset(void *s, int c, cgc_size_t n)
+{
+ if (s == NULL)
+ return NULL;
+
+ if (n == 0)
+ return s;
+
+ unsigned char *p = s;
+ cgc_size_t i;
+ for(i = 0; i < n; i++)
+ *p++ = (unsigned char) c;
+
+ return s;
+}
diff --git a/cgc-challenges/Accel/lib/printf.c b/cgc-challenges/Accel/lib/printf.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c09ced65aa124a1fe833436ecb46b432e1aac1c
--- /dev/null
+++ b/cgc-challenges/Accel/lib/printf.c
@@ -0,0 +1,250 @@
+/*
+ * Author: Andrew Wesie <andrew.wesie@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "cgc_stdlib.h"
+#include "cgc_stdarg.h"
+#include "cgc_string.h"
+
+#define OUTPUT_BYTE(x) do { \
+ cgc_size_t bytes; \
+ char _c = x; \
+ cgc_transmit(STDOUT, &_c, sizeof(_c), &bytes); \
+} while (0);
+
+#define NUM_TO_LOWER(x) (((x) < 10 ? (x)+'0' : (x)-10+'a'))
+#define NUM_TO_UPPER(x) (((x) < 10 ? (x)+'0' : (x)-10+'A'))
+
+#define FLAG_PAD_ZERO 0x1
+#define FLAG_UPPERCASE 0x2
+int cgc_output_number_printf(unsigned int x, int base, int min, unsigned int flags)
+{
+ int n = 0;
+ if (x >= base)
+ {
+ n = cgc_output_number_printf(x / base, base, min-1, flags);
+ x %= base;
+ }
+ if (n == 0 && min > 0)
+ {
+ while (--min)
+ if (flags & FLAG_PAD_ZERO)
+ OUTPUT_BYTE('0')
+ else
+ OUTPUT_BYTE(' ')
+ }
+
+ if (flags & FLAG_UPPERCASE)
+ OUTPUT_BYTE(NUM_TO_UPPER(x))
+ else
+ OUTPUT_BYTE(NUM_TO_LOWER(x))
+ return n + 1;
+}
+
+int cgc_printf(const char *fmt, ...)
+{
+ char *astring;
+ int aint, i, n = 0, flags = 0, min = 0;
+ unsigned int auint;
+ va_list ap;
+ va_start(ap, fmt);
+
+ while (*fmt != '\0')
+ {
+ char c = *fmt++;
+ if (c == '%')
+ {
+ while (1)
+ {
+ c = *fmt++;
+ switch (c)
+ {
+ case '0':
+ flags |= FLAG_PAD_ZERO;
+ continue;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ min = cgc_strtol(fmt-1, (char**)&fmt, 10);
+ continue;
+ }
+ break;
+ }
+ switch (c)
+ {
+ case '%':
+ OUTPUT_BYTE('%')
+ break;
+ case 's':
+ astring = va_arg(ap, char *);
+ for (i = 0; i < cgc_strlen(astring); i++)
+ OUTPUT_BYTE(astring[i]);
+ break;
+ case 'd':
+ aint = va_arg(ap, int);
+ if (aint < 0)
+ {
+ OUTPUT_BYTE('-')
+ aint = -aint;
+ }
+ cgc_output_number_printf(aint, 10, min, flags);
+ break;
+ case 'X':
+ flags |= FLAG_UPPERCASE;
+ case 'x':
+ auint = va_arg(ap, unsigned int);
+ cgc_output_number_printf(auint, 16, min, flags);
+ break;
+ default:
+ OUTPUT_BYTE(c)
+ break;
+ }
+ min = 0;
+ flags = 0;
+ }
+ else
+ {
+ OUTPUT_BYTE(c)
+ }
+ }
+
+ va_end(ap);
+ return n;
+}
+
+#undef OUTPUT_BYTE
+
+#define OUTPUT_BYTE(n, s, x) do { \
+ cgc_size_t bytes; \
+ char _c = x; \
+ *(*(s)) = _c; \
+ (*(s))++; \
+ (*(n))++; \
+} while (0);
+
+void cgc_output_number_sprintf(int *n, char **s, unsigned int x, int base, int min, unsigned int flags)
+{
+ if (x >= base)
+ {
+ cgc_output_number_sprintf(n, s, x / base, base, min-1, flags);
+ x %= base;
+ }
+ if (x < base && min > 0)
+ {
+ while (--min)
+ if (flags & FLAG_PAD_ZERO)
+ OUTPUT_BYTE(n, s, '0')
+ else
+ OUTPUT_BYTE(n, s, ' ')
+ }
+
+ if (flags & FLAG_UPPERCASE)
+ OUTPUT_BYTE(n, s, NUM_TO_UPPER(x))
+ else
+ OUTPUT_BYTE(n, s, NUM_TO_LOWER(x))
+}
+
+int cgc_sprintf(char *str, const char *fmt, ...)
+{
+ char *astring;
+ int aint, i, n = 0, flags = 0, min = 0;
+ unsigned int auint;
+ va_list ap;
+ va_start(ap, fmt);
+
+ while (*fmt != '\0')
+ {
+ char c = *fmt++;
+ if (c == '%')
+ {
+ while (1)
+ {
+ c = *fmt++;
+ switch (c)
+ {
+ case '0':
+ flags |= FLAG_PAD_ZERO;
+ continue;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ min = cgc_strtol(fmt-1, (char**)&fmt, 10);
+ continue;
+ }
+ break;
+ }
+ switch (c)
+ {
+ case '%':
+ OUTPUT_BYTE(&n, &str, '%')
+ break;
+ case 's':
+ astring = va_arg(ap, char *);
+ for (i = 0; i < cgc_strlen(astring); i++)
+ OUTPUT_BYTE(&n, &str, astring[i]);
+ break;
+ case 'd':
+ aint = va_arg(ap, int);
+ if (aint < 0)
+ {
+ OUTPUT_BYTE(&n, &str, '-')
+ aint = -aint;
+ }
+ cgc_output_number_sprintf(&n, &str, aint, 10, min, flags);
+ break;
+ case 'X':
+ flags |= FLAG_UPPERCASE;
+ case 'x':
+ auint = va_arg(ap, unsigned int);
+ cgc_output_number_sprintf(&n, &str, auint, 16, min, flags);
+ break;
+ default:
+ OUTPUT_BYTE(&n, &str, c)
+ break;
+ }
+ min = 0;
+ flags = 0;
+ }
+ else
+ {
+ OUTPUT_BYTE(&n, &str, c)
+ }
+ }
+ *str++ = 0;
+
+ va_end(ap);
+ return n;
+}
+
diff --git a/cgc-challenges/Accel/lib/realloc.c b/cgc-challenges/Accel/lib/realloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ae2029b399f4354ee35215b08bbc8a13f59ae2f
--- /dev/null
+++ b/cgc-challenges/Accel/lib/realloc.c
@@ -0,0 +1,55 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_malloc.h"
+#include "cgc_stdlib.h"
+#include "cgc_stdint.h"
+#include "cgc_string.h"
+
+void *cgc_realloc(void *ptr, cgc_size_t size)
+{
+ if (ptr == NULL)
+ return cgc_malloc(size);
+
+ if (size == 0) {
+ cgc_free(ptr);
+ return NULL;
+ }
+
+ void *new = cgc_malloc(size);
+ if (new == NULL)
+ return NULL;
+
+ struct blk_t *blk = (struct blk_t *)((intptr_t)ptr - HEADER_PADDING);
+
+ if (size < blk->size - HEADER_PADDING)
+ cgc_memcpy(new, ptr, size);
+ else
+ cgc_memcpy(new, ptr, blk->size - HEADER_PADDING);
+
+ cgc_free(ptr);
+ return new;
+}
diff --git a/cgc-challenges/Accel/lib/strchr.c b/cgc-challenges/Accel/lib/strchr.c
new file mode 100644
index 0000000000000000000000000000000000000000..9460e534b338b9ce0d3f1944d22fa720da5abc50
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strchr.c
@@ -0,0 +1,37 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+
+char *cgc_strchr(const char *s, int c)
+{
+ const char *p = s;
+
+ while (*p)
+ if (*p++ == c)
+ return (char *) p;
+
+ return NULL;
+}
diff --git a/cgc-challenges/Accel/lib/strcmp.c b/cgc-challenges/Accel/lib/strcmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac5741f12775e42471312dc2c1d38255aab50534
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strcmp.c
@@ -0,0 +1,37 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+
+int cgc_strcmp(const char *s1, const char *s2)
+{
+ while (*s1 && *s2)
+ if (*s1 != *s2)
+ break;
+ else
+ s1++, s2++;
+
+ return *s2 - *s1;
+}
diff --git a/cgc-challenges/Accel/lib/strcpy.c b/cgc-challenges/Accel/lib/strcpy.c
new file mode 100644
index 0000000000000000000000000000000000000000..ef02810a3eb8769a90361268744ce7064809278d
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strcpy.c
@@ -0,0 +1,36 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "cgc_string.h"
+
+char *cgc_strcpy(char *dest, const char *src)
+{
+ cgc_size_t i = 0;
+ while (*src)
+ dest[i++] = *src++;
+
+ dest[i] = '\0';
+ return dest;
+}
diff --git a/cgc-challenges/Accel/lib/strlen.c b/cgc-challenges/Accel/lib/strlen.c
new file mode 100755
index 0000000000000000000000000000000000000000..6d26d13620ae32db57261bf100a015113e419482
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strlen.c
@@ -0,0 +1,36 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_string.h"
+
+cgc_size_t cgc_strlen(const char *s)
+{
+ const char *p = s;
+ while (*p)
+ p++;
+
+ return p - s;
+}
diff --git a/cgc-challenges/Accel/lib/strsep.c b/cgc-challenges/Accel/lib/strsep.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a5a4268a96c57842b556ed895f7b6a9810358a6
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strsep.c
@@ -0,0 +1,47 @@
+/*
+ * Author: Garrett Barboza <garrett.barboza@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+#include "libcgc.h"
+#include "cgc_string.h"
+
+char *cgc_strsep(char **stringp, const char *delim)
+{
+ if (*stringp == NULL)
+ return NULL;
+
+ char *i;
+ for (i = *stringp; *i && !cgc_strchr(delim, *i); i++);
+
+ delim = *stringp;
+
+ if (*i) {
+ *i = '\0';
+ *stringp = i + 1;
+ } else {
+ *stringp = NULL;
+ }
+
+ return (char *) delim;
+}
diff --git a/cgc-challenges/Accel/lib/strtol.c b/cgc-challenges/Accel/lib/strtol.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ddcd02d6704454ca93b84a8d3298097d7100469
--- /dev/null
+++ b/cgc-challenges/Accel/lib/strtol.c
@@ -0,0 +1,127 @@
+/*
+ * Author: Brian Pak <brian.pak@kapricasecurity.com>
+ *
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#define IS_SPACE(c) ((c == ' ') || (c == '\t') || (c == '\f') || (c == '\n') || (c == '\v'))
+#define IS_NUM(c) ((c >= '0') && (c <= '9'))
+#define IS_ALPHA(c) (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')))
+#define IS_UPPER(c) ((c >= 'A') && (c <= 'Z'))
+
+long int cgc_strtol(const char *nptr, char **endptr, int base)
+{
+ int limit;
+ int neg = 0, val = 0, consumed = 0, n, a;
+ const char *p = nptr;
+
+ /* Check validity of base */
+ if (base == 1 || base > 36 || base < 0)
+ goto done;
+
+ /* Skip white space */
+ while (1)
+ {
+ if (IS_SPACE(*p))
+ ++p;
+ else
+ break;
+ }
+
+ /* Check sign symbol */
+ if (*p == '-')
+ {
+ neg = 1;
+ ++p;
+ }
+ if (*p == '+')
+ ++p;
+
+ /* Handle the base & its syntax */
+ switch (base)
+ {
+ case 0:
+ if (*p == '0')
+ {
+ if (p[1] == 'x' || p[1] == 'X')
+ {
+ p += 2;
+ base = 16;
+ }
+ else
+ {
+ ++p;
+ base = 8;
+ }
+ }
+ else
+ base = 10;
+ break;
+ case 16:
+ if (*p == '0' && (p[1] == 'x' || p[1] == 'X'))
+ {
+ p += 2;
+ base = 16;
+ }
+ break;
+ }
+
+ /* Convert the rest of the string into int */
+ while ((n = IS_NUM(*p)) || (a = IS_ALPHA(*p)))
+ {
+ if (n)
+ n = *p - '0';
+ else if (a)
+ {
+ if (IS_UPPER(*p))
+ n = *p - 'A';
+ else
+ n = *p - 'a';
+ // "... In bases above 10, the letter 'A' in either upper or lower case represents 10,
+ // 'B' represents 11, and so forth, with 'Z' representing 35. ..."
+ n += 10;
+ }
+
+ // "... stopping at the first character which is not a valid digit in the given base. ..."
+ if (n >= base)
+ break;
+
+ val *= base;
+ val += n;
+ ++consumed;
+ ++p;
+ }
+
+ if (neg)
+ val = -val;
+
+done:
+ if (endptr)
+ *endptr = (char *)(consumed > 0 ? p : nptr);
+
+ return val;
+
+}
+
+long unsigned int cgc_strtoul(const char *nptr, char **endptr, int base)
+{
+ return (long unsigned int)cgc_strtol(nptr, endptr, base);
+}
diff --git a/cgc-challenges/Accel/main.c b/cgc-challenges/Accel/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..cc6521e874d5b6135af8feb4a1e19cc66e77c13b
--- /dev/null
+++ b/cgc-challenges/Accel/main.c
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include "libcgc.h"
+
+
+
+
+
+
+#include "cgc_accel.h"
+#include "cgc_accelio.h"
+#include "cgc_convert.h"
+
+#define ASSIGN "ASSIGN"
+#define CLEAR "CLEAR "
+#define REPR "REPR "
+#define SHOW "SHOW "
+#define TABLE "TABLE"
+#define EXIT "EXIT"
+
+#define BAD_CLEAR_CMD -8
+#define BAD_ASSIGN_CMD -4
+#define BAD_SHOW_CMD -2
+#define BAD_INPUT -1
+#define CMD_SUCCESS 0
+#define EXIT_CODE 1
+
+#define LINE_SIZE 512
+
+static void cgc_print_table() {
+ cgc_print_assigned_cells();
+}
+
+static int cgc_readline(int fd, char *line, size_t line_size)
+{
+ size_t i;
+ size_t rx;
+
+ for (i = 0; i < line_size; i++) {
+ if (cgc_receive(fd, line, 1, &rx) != 0 || rx == 0)
+ exit(0);
+ if (*line == '\n')
+ break;
+ line++;
+ }
+
+ if (i == line_size && *line != '\n')
+ return -1;
+ else if (*line != '\n')
+ return 1;
+ else
+ *line = '\0';
+
+ return 0;
+}
+
+static int cgc_parse_line(char *line)
+{
+ int is_repr = 0;
+ size_t i;
+ char tmp[32];
+ char *tok;
+ char val_str[LINE_SIZE];
+ char *cell_str;
+
+ if (cgc_strtrim(line, LINE_SIZE, TRIM_FRONT) == -1)
+ return BAD_INPUT;
+
+ memcpy(tmp, line, strlen(SHOW));
+ for (i = 0; i < strlen(SHOW); i++)
+ tmp[i] = toupper(tmp[i]);
+
+ if (memcmp(tmp, SHOW, strlen(SHOW)) == 0)
+ goto show_cmd;
+
+ memcpy(tmp, line, strlen(REPR));
+ for (i = 0; i < strlen(REPR); i++)
+ tmp[i] = toupper(tmp[i]);
+
+ if (memcmp(tmp, REPR, strlen(REPR)) == 0) {
+ is_repr = 1;
+ goto show_cmd;
+ }
+
+ memcpy(tmp, line, strlen(CLEAR));
+ for (i = 0; i < strlen(CLEAR); i++)
+ tmp[i] = toupper(tmp[i]);
+
+ if (memcmp(tmp, CLEAR, strlen(CLEAR)) == 0)
+ goto clear_cmd;
+
+ // Use sizeof to include null terminator (vs strlen)
+ memcpy(tmp, line, sizeof(EXIT));
+ for (i = 0; i < sizeof(EXIT); i++)
+ tmp[i] = toupper(tmp[i]);
+
+ if (memcmp(tmp, EXIT, sizeof(EXIT)) == 0)
+ goto exit_cmd;
+
+ goto assign_cmd;
+
+show_cmd:
+ cgc_strtrim(line, LINE_SIZE, TRIM_BACK);
+ memcpy(tmp, &line[strlen(SHOW)], sizeof(TABLE));
+ for (i = 0; i < sizeof(TABLE); i++)
+ tmp[i] = toupper(tmp[i]);
+
+ // Use sizeof to include null terminator (vs strlen)
+ if (memcmp(tmp, TABLE, sizeof(TABLE)) == 0) {
+ cgc_print_table();
+ return CMD_SUCCESS;
+ } else if (cgc_valid_cell_id(&line[strlen(SHOW)]) != -1) {
+ cell_str = cgc_show_cell(&line[strlen(SHOW)], is_repr, val_str, LINE_SIZE);
+ if (is_repr)
+ printf("Cell Repr: %s\n", cell_str);
+ else
+ printf("Cell Value: %s\n", cell_str);
+ return CMD_SUCCESS;
+ } else {
+ return BAD_SHOW_CMD;
+ }
+
+clear_cmd:
+ if (cgc_clear_cell(&line[strlen(CLEAR)]) != 0)
+ return BAD_CLEAR_CMD;
+
+ return CMD_SUCCESS;
+
+assign_cmd:
+ tok = strsep(&line, "=");
+ if (tok == NULL || line == NULL)
+ return BAD_INPUT;
+
+ if (cgc_set_cell(tok, line, LINE_SIZE) != 0)
+ return BAD_ASSIGN_CMD;
+
+ return CMD_SUCCESS;
+
+exit_cmd:
+ return EXIT_CODE;
+}
+
+int main(int cgc_argc, char *cgc_argv[]) {
+ char line[LINE_SIZE];
+ cgc_init_sheet();
+ int exit = 0;
+ int line_status;
+
+ do {
+ printf("Accel:-$ ");
+ line_status = cgc_readline(STDIN, line, LINE_SIZE);
+ if(line_status != 0) {
+ printf("\n");
+ continue;
+ }
+
+ switch (cgc_parse_line(line)) {
+ case BAD_CLEAR_CMD:
+ printf("Error clearing cell\n");
+ break;
+ case BAD_ASSIGN_CMD:
+ printf("Error assigning cell. Valid Cells: A0-ZZ99\n");
+ break;
+ case BAD_SHOW_CMD:
+ printf("Error showing data. Try SHOW TABLE or SHOW [A0-ZZ99]\n");
+ break;
+ case BAD_INPUT:
+ printf("Bad input\n");
+ break;
+ case CMD_SUCCESS:
+ printf("Success.\n");
+ break;
+ case EXIT_CODE:
+ exit = 1;
+ printf("Exiting...\n");
+ return 0;
+ default:
+ printf("Unknown Input\n");
+ break;
+ }
+ } while (!exit);
+
+ printf("Unsupported signal. Exiting...\n");
+ return 0;
+}
+
diff --git a/cgc-challenges/Accel/queue.c b/cgc-challenges/Accel/queue.c
new file mode 100644
index 0000000000000000000000000000000000000000..12f870181c30c3948359089b3efdd208e8ae340a
--- /dev/null
+++ b/cgc-challenges/Accel/queue.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+
+
+#include "cgc_queue.h"
+
+char *cgc_peek_front(queue_t *queue)
+{
+ if (queue == NULL)
+ return NULL;
+
+ return queue->data;
+}
+
+int cgc_enqueue(queue_t **queue, char *data)
+{
+ if (data == NULL)
+ return -1;
+
+ queue_t *back = malloc(sizeof(queue_t));
+ back->data = data;
+ back->next = NULL;
+
+ if(*queue == NULL) {
+ *queue = back;
+ } else {
+ queue_t *iter = *queue;
+ while (iter->next != NULL)
+ iter = iter->next;
+
+ iter->next = back;
+ }
+
+ return 0;
+}
+
+int cgc_enqueue_copy(queue_t **queue, char *data, size_t size)
+{
+ if (data == NULL)
+ return -1;
+
+ int data_len = strlen(data) + 1;
+ if (data_len > size)
+ return -1;
+
+ queue_t *back = malloc(sizeof(queue_t));
+ back->data = malloc(data_len);
+ memcpy(back->data, data, data_len);
+ back->next = NULL;
+
+ if(*queue == NULL) {
+ *queue = back;
+ } else {
+ queue_t *iter = *queue;
+ while (iter->next != NULL)
+ iter = iter->next;
+
+ iter->next = back;
+ }
+
+ return 0;
+}
+
+char *cgc_dequeue_copy(queue_t **queue)
+{
+ if(*queue == NULL)
+ return NULL;
+
+ queue_t *front = *queue;
+ char *popped_data = front->data;
+ *queue = front->next;
+ free(front);
+
+ return popped_data;
+}
+
+
+void cgc_clear_queue(queue_t **queue)
+{
+ if (*queue == NULL)
+ return;
+
+ queue_t *front = *queue, *old_front;
+ while(front->next != NULL) {
+ free(front->data);
+ old_front = front;
+ front = front->next;
+ free(old_front);
+ }
+ free(front->data);
+ free(front);
+ *queue = NULL;
+}
diff --git a/cgc-challenges/Accel/stack.c b/cgc-challenges/Accel/stack.c
new file mode 100644
index 0000000000000000000000000000000000000000..83f7e465461a2c5604aed3cdf4e8715a5955b0d0
--- /dev/null
+++ b/cgc-challenges/Accel/stack.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2014 Kaprica Security, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+
+
+#include "cgc_stack.h"
+
+char *cgc_peek_top(stack_t *stack)
+{
+ if(stack == NULL)
+ return NULL;
+
+ return stack->data;
+}
+
+int cgc_push(stack_t **stack, char *data)
+{
+ if (data == NULL)
+ return -1;
+
+ stack_t *top = malloc(sizeof(stack_t));
+ top->data = data;
+
+ if(*stack == NULL) {
+ top->next = NULL;
+ *stack = top;
+ } else {
+ top->next = *stack;
+ *stack = top;
+ }
+
+ return 0;
+}
+
+int cgc_push_copy(stack_t **stack, char *data, size_t size)
+{
+ if (data == NULL)
+ return -1;
+
+ int data_len = strlen(data) + 1;
+ if (data_len > size)
+ return -1;
+
+ stack_t *top = malloc(sizeof(stack_t));
+ top->data = malloc(data_len);
+ memcpy(top->data, data, data_len);
+
+ if(*stack == NULL) {
+ top->next = NULL;
+ *stack = top;
+ } else {
+ top->next = *stack;
+ *stack = top;
+ }
+
+ return 0;
+}
+
+char *cgc_pop_copy(stack_t **stack)
+{
+ if(*stack == NULL)
+ return NULL;
+
+ stack_t *top = *stack;
+ char *popped_data = top->data;
+ *stack = top->next;
+ free(top);
+
+ return popped_data;
+}
+
+
+void cgc_clear_stack(stack_t **stack)
+{
+ if (*stack == NULL)
+ return;
+
+ stack_t *top = *stack, *old_top;
+ while(top->next != NULL) {
+ free(top->data);
+ old_top = top;
+ top = top->next;
+ free(old_top);
+ }
+ free(top->data);
+ free(top);
+ *stack = NULL;
+}
diff --git a/cgc-challenges/lib/common.c b/cgc-challenges/lib/common.c
index f0aadb9a86b15e5b813c18ebf7894f04b210b2a6..6e945c075992daa32ab457a087c2304857d85228 100644
--- a/cgc-challenges/lib/common.c
+++ b/cgc-challenges/lib/common.c
@@ -34,3 +34,23 @@ size_t rxbytes;
return 0;
}
+
+char *strsep(char **stringp, const char *delim)
+{
+ if (*stringp == NULL)
+ return NULL;
+
+ char *i;
+ for (i = *stringp; *i && !strchr(delim, *i); i++);
+
+ delim = *stringp;
+
+ if (*i) {
+ *i = '\0';
+ *stringp = i + 1;
+ } else {
+ *stringp = NULL;
+ }
+
+ return (char *) delim;
+}
diff --git a/cgc-challenges/lib/common.h b/cgc-challenges/lib/common.h
index b2441583047b472c0cd8b6c6da227e383de86f9b..f7f0ca5e985ad2d746a8cfb232f6388d66b4401c 100644
--- a/cgc-challenges/lib/common.h
+++ b/cgc-challenges/lib/common.h
@@ -1,6 +1,7 @@
#ifndef _COMMON_H
#define _COMMON_H
+#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
@@ -14,6 +15,8 @@
#include <sys/types.h>
#include <unistd.h>
+#include "fc_stubs.h"
+
int receive_bytes_iPcz (char *buffer, size_t count);
int __prng_state;
@@ -24,4 +27,6 @@ void seed_prng( uint32_t seedValue );
/*@ assigns \result, __prng_state \from __prng_state; */
uint32_t cgc_prng( void );
+char *strsep(char **stringp, const char *delim);
+
#endif
diff --git a/cgc-challenges/lib/fc_stubs.h b/cgc-challenges/lib/fc_stubs.h
new file mode 100644
index 0000000000000000000000000000000000000000..154f342e50b4ec93daf6a3ea699984b94ddd1955
--- /dev/null
+++ b/cgc-challenges/lib/fc_stubs.h
@@ -0,0 +1,4 @@
+#include <math.h>
+
+/*@ assigns \result \from x, y; */
+extern double remainder(double x, double y);
diff --git a/cgc-challenges/normalize.sh b/cgc-challenges/normalize.sh
new file mode 100755
index 0000000000000000000000000000000000000000..6b6c26322e576f1589681f83b99cb439b1a58d3a
--- /dev/null
+++ b/cgc-challenges/normalize.sh
@@ -0,0 +1,35 @@
+#!/bin/bash -eu
+
+if [ $# -lt 1 ]; then
+ echo "usage: $0 files"
+ exit 1
+fi
+
+sed -i 's/cgc_calloc/calloc/g' $*
+sed -i 's/cgc_fabs/fabs/g' $*
+sed -i 's/cgc_cos/cos/g' $*
+sed -i 's/cgc_exit/exit/g' $*
+sed -i 's/cgc_free/free/g' $*
+sed -i 's/cgc_log/log/g' $*
+sed -i 's/cgc_malloc/malloc/g' $*
+sed -i 's/cgc_memcmp/memcmp/g' $*
+sed -i 's/cgc_memcpy/memcpy/g' $*
+sed -i 's/cgc_pow/pow/g' $*
+sed -i 's/cgc_printf/printf/g' $*
+sed -i 's/cgc_realloc/realloc/g' $*
+sed -i 's/cgc_remainder/remainder/g' $*
+sed -i 's/cgc_sin/sin/g' $*
+sed -i 's/cgc_size_t/size_t/g' $*
+sed -i 's/cgc_sqrt/sqrt/g' $*
+sed -i 's/cgc_strchr/strchr/g' $*
+sed -i 's/cgc_strcmp/strcmp/g' $*
+sed -i 's/cgc_strcpy/strcpy/g' $*
+sed -i 's/cgc_strlen/strlen/g' $*
+sed -i 's/cgc_strtol/strtol/g' $*
+sed -i 's/cgc_tolower/tolower/g' $*
+sed -i 's/cgc_toupper/toupper/g' $*
+
+sed -i 's/#include "cgc_ctype.h"//' $*
+sed -i 's/#include "cgc_stdarg.h"//' $*
+sed -i 's/#include "cgc_stdlib.h"//' $*
+sed -i 's/#include "cgc_string.h"//' $*