bool
explode_ucs2_ucs2 (RECODE_CONST_STEP step, RECODE_TASK task)
{
Hash_table *table = step->step_table;
unsigned value;
if (get_ucs2 (&value, step, task))
{
if (task->byte_order_mark)
put_ucs2 (BYTE_ORDER_MARK, task);
while (true)
{
unsigned short lookup = value;
unsigned short *result = hash_lookup (table, &lookup);
if (result)
{
result++;
while (*result != DONE && *result != ELSE)
put_ucs2 (*result++, task);
}
else
put_ucs2 (value, task);
if (!get_ucs2 (&value, step, task))
break;
}
}
TASK_RETURN (task);
}
bool
explode_ucs2_ucs2 (RECODE_SUBTASK subtask)
{
Hash_table *table = (Hash_table *) subtask->step->step_table;
unsigned value;
if (get_ucs2 (&value, subtask))
{
if (subtask->task->byte_order_mark)
put_ucs2 (BYTE_ORDER_MARK, subtask);
while (true)
{
unsigned short lookup = value;
unsigned short *result
= (unsigned short *) hash_lookup (table, &lookup);
if (result)
{
result++;
while (*result != DONE && *result != ELSE)
put_ucs2 (*result++, subtask);
}
else
put_ucs2 (value, subtask);
if (!get_ucs2 (&value, subtask))
break;
}
}
SUBTASK_RETURN (subtask);
}
bool
combine_ucs2_ucs2 (RECODE_SUBTASK subtask)
{
unsigned value;
if (get_ucs2 (&value, subtask))
{
struct state *state = NULL;
if (subtask->task->byte_order_mark)
put_ucs2 (BYTE_ORDER_MARK, subtask);
while (true)
{
struct state *shift
= find_shifted_state (state, value, subtask->step);
if (shift)
{
state = shift;
if (!get_ucs2 (&value, subtask))
break;
}
else if (state)
{
if (state->result == NOT_A_CHARACTER)
backtrack_ucs2 (state, subtask);
else
put_ucs2 (state->result, subtask);
state = NULL;
}
else
{
put_ucs2 (value, subtask);
if (!get_ucs2 (&value, subtask))
break;
}
}
if (state)
{
if (state->result == NOT_A_CHARACTER)
backtrack_ucs2 (state, subtask);
else
put_ucs2 (state->result, subtask);
}
}
SUBTASK_RETURN (subtask);
}
bool
explode_ucs2_byte (RECODE_SUBTASK subtask)
{
Hash_table *table = (Hash_table *) subtask->step->step_table;
unsigned value;
while (get_ucs2 (&value, subtask))
{
unsigned short lookup = value;
unsigned short *result = (unsigned short *) hash_lookup (table, &lookup);
if (result)
{
result++;
while (*result != DONE && *result != ELSE)
{
put_byte (*result, subtask);
result++;
}
}
else
put_byte (value, subtask);
}
SUBTASK_RETURN (subtask);
}
bool
explode_ucs2_byte (RECODE_CONST_STEP step, RECODE_TASK task)
{
Hash_table *table = step->step_table;
unsigned value;
while (get_ucs2 (&value, step, task))
{
unsigned short lookup = value;
unsigned short *result = hash_lookup (table, &lookup);
if (result)
{
result++;
while (*result != DONE && *result != ELSE)
{
put_byte (*result, task);
result++;
}
}
else
put_byte (value, task);
}
TASK_RETURN (task);
}
bool
combine_ucs2_byte (RECODE_CONST_STEP step, RECODE_TASK task)
{
struct state *state = NULL;
unsigned value;
if (get_ucs2 (&value, step, task))
{
while (true)
{
struct state *shift = find_shifted_state (state, value, step);
if (shift)
{
state = shift;
if (!get_ucs2 (&value, step, task))
break;
}
else if (state)
{
if (state->result == NOT_A_CHARACTER)
backtrack_byte (state, task);
else
put_byte (state->result, task);
state = NULL;
}
else
{
put_byte (value, task);
if (!get_ucs2 (&value, step, task))
break;
}
}
if (state)
if (state->result == NOT_A_CHARACTER)
backtrack_byte (state, task);
else
put_byte (state->result, task);
}
TASK_RETURN (task);
}
static bool
transform_ucs2_html (RECODE_SUBTASK subtask)
{
Hash_table *table = subtask->step->step_table;
unsigned value;
while (get_ucs2 (&value, subtask))
{
struct ucs2_to_string lookup;
struct ucs2_to_string *entry;
lookup.code = value;
entry = hash_lookup (table, &lookup);
if (entry)
{
const char *cursor = entry->string;
put_byte ('&', subtask);
while (*cursor)
{
put_byte (*cursor, subtask);
cursor++;
}
put_byte (';', subtask);
}
else if ((value < 32 && value != '\n' && value != '\t') || value >= 127)
{
unsigned divider = 10000;
put_byte ('&', subtask);
put_byte ('#', subtask);
while (divider > value)
divider /= 10;
while (divider > 1)
{
put_byte ('0' + value / divider, subtask);
value %= divider;
divider /= 10;
}
put_byte ('0' + value, subtask);
put_byte (';', subtask);
}
else
put_byte(value, subtask);
}
SUBTASK_RETURN (subtask);
}
static bool
transform_utf16_utf7 (RECODE_CONST_STEP step, RECODE_TASK task)
{
int character;
unsigned value;
if (!get_ucs2 (&value, step, task))
TASK_RETURN (task);
while (true)
if (IS_BODY_DIRECT (value))
{
/* Copy one direct character. */
put_byte (value, task);
if (!get_ucs2 (&value, step, task))
TASK_RETURN (task);
}
else
{
/* Copy a string of non-direct characters. */
put_byte ('+', task);
while (!IS_BODY_DIRECT (value))
{
unsigned split;
/* Process first UCS-2 value of a triplet. */
put_byte (base64_value_to_char[MASK (6) & value >> 10], task);
put_byte (base64_value_to_char[MASK (6) & value >> 4], task);
split = (value & MASK (4)) << 2;
if (!get_ucs2 (&value, step, task))
{
put_byte (base64_value_to_char[split], task);
TASK_RETURN (task);
}
/* Process second UCS-2 value of a triplet. */
if (IS_BODY_DIRECT (value))
{
put_byte (base64_value_to_char[split], task);
break;
}
put_byte (base64_value_to_char[split | (MASK (2) & value >> 14)],
task);
put_byte (base64_value_to_char[MASK (6) & value >> 8], task);
put_byte (base64_value_to_char[MASK (6) & value >> 2], task);
split = (value & MASK (2)) << 4;
if (!get_ucs2 (&value, step, task))
{
put_byte (base64_value_to_char[split], task);
TASK_RETURN (task);
}
/* Process third UCS-2 value of a triplet. */
if (IS_BODY_DIRECT (value))
{
put_byte (base64_value_to_char[split], task);
break;
}
put_byte (base64_value_to_char[split | (MASK (4) & value >> 12)],
task);
put_byte (base64_value_to_char[MASK (6) & value >> 6], task);
put_byte (base64_value_to_char[MASK (6) & value], task);
if (!get_ucs2 (&value, step, task))
TASK_RETURN (task);
}
if (IS_BASE64 (value))
put_byte ('-', task);
}
TASK_RETURN (task);
}
