/* This functions is only used when unmarshalling.
* The assumptions made here are therefore safe.
* String#to_f uses string_to_double
*/
OBJECT float_from_string(STATE, char *str) {
char *endp;
double d;
d = strtod(str, &endp);
if (str != endp && *endp == '\0') {
return float_new(state, d);
}
/* When we get here, we might have a system that doesn't conform to
C99 (OpenBSD is at least one) that can't handle Infinity / NaN.
We test the strings here manually and fix it if needed. */
int sign = 0;
if (*str == '-') {
sign = 1;
str++;
} else if (*str == '+') {
str++;
}
if (*str == 'I' || *str == 'i') {
return float_new(state, sign ? -HUGE_VAL : HUGE_VAL);
}
if (*str == 'N' || *str == 'n') {
word0(d) = 0x7ff80000;
word1(d) = 0;
return float_new(state, d);
}
return Qnil;
}
void reduce_do(char* buf, const size_t total, const std::string &out_folder){
yucha::tool::recursive_mkdir(out_folder.c_str());
size_t prev = 0;
size_t split = 0;
std::pair<size_t , size_t> p;
MyHash h(buf);
MyHashEq e(buf);
MYMAP uni(3 , h , e);
{
size_t spaces[3];
for(size_t i = 0 ; i < total; ++i){
prev = i;
unsigned short int count = 0;
bool error = false;
for(; buf[i] != '\n'; ++i){ //get freq
if(buf[i] == '\t'){
if (count==2){
error = true;
}
else{
spaces[count] = i;
++count;
};
};
};
if (count!=2 or error)
continue;
buf[spaces[0]] = ' ';
const size_t end_1 = spaces[0];
const size_t end_2 = spaces[1];
const size_t tail = i;
std::pair<size_t , size_t> word1(prev, end_1);
std::pair<size_t , size_t> word2(end_1+1 , end_2);
buf[tail] = '\0';
const unsigned long freq = atoi(&buf[end_2]);
add(uni, word1, freq);
add(uni, word2, freq);
};
}
printout(1, uni, out_folder, buf, 0);
};
#if defined(IEEE_Arith) + defined(VAX)
if ((word0 (d) & Exp_mask) == Exp_mask)
#else
if (word0 (d) == 0x8000)
#endif
{
/* Infinity or NaN */
*decpt = 9999;
s =
#ifdef IEEE_Arith
!word1 (d) && !(word0 (d) & 0xfffff) ? "Infinity" :
#endif
"NaN";
if (rve)
*rve =
#ifdef IEEE_Arith
s[3] ? s + 8 :
#endif
s + 3;
return s;
}
void
tex_font_metric_rep::execute (int* s, int n, int* buf, int* ker, int& m) {
STACK_NEW_ARRAY (stack, int, m);
int bp, sp=0, i;
for (i=0; i<n; i++) stack[sp++]= s[n-1-i];
sp--; bp= 0;
while (sp>=0) {
int cur_char= stack [sp]& 255;
// cout << "Processing " << (char) cur_char << "\n";
/***************** the ligature-kerning program ******************/
if ((cur_char<bc) || (cur_char>ec)) sp--;
else if ((tag (cur_char)==1) && (sp>0)) {
register int next_char= stack [sp-1]& 255;
register int pc= rem (cur_char);
if (byte0 (lig_kern [pc]) > 128) pc= word1 (lig_kern [pc]);
while (true) {
register int instr= lig_kern [pc];
//if (byte0 (instr) >= 128) { // halt
// // cout << " Halt\n";
// ker [bp] = 0;
// buf [bp++]= stack[sp--];
// break;
//}
if (byte1 (instr) != next_char) { // continue
// cout << " " << (char) byte1 (instr) << " != " << (char) next_char
// << " => pc := pc + " << (byte0 (instr)+1) << "\n";
int skip_byte = byte0(instr);
if (skip_byte >= 128) { // current instruction is the final instruction
// cout << " Halt\n";
ker [bp] = 0;
buf [bp++]= stack[sp--];
break;
}
else {
pc += skip_byte+1;
continue;
}
}
// cout << " " << (char) byte1 (instr) << " == "
// << (char) next_char << " => ";
if (byte2 (instr) < 128) { // ligature
// cout << "Ligature ";
int code= byte2 (instr);
int a = code>>2;
int b = (code>>1)&1;
int c = code&1;
// cout << "(" << a << "," << b << "," << c << ")\n";
if (b==0) sp--;
stack [sp++]= byte3 (instr);
if (c!=0) stack[sp++]= cur_char;
sp--;
while (a>0) {
ker [bp] = 0;
buf [bp++]= stack [sp--];
a--;
}
break;
}
else { // kerning
// cout << "Kerning (" << kern [word1x (instr)] << ")\n";
ker [bp] = kern [word1x (instr)];
buf [bp++]= stack [sp--];
break;
}
}
}
void reduce_do(char* buf, const size_t total, const std::string &out_folder){
yucha::tool::recursive_mkdir(out_folder.c_str());
size_t prev = 0;
size_t split = 0;
std::pair<size_t , size_t> p;
MyHash h(buf);
MyHashEq e(buf);
MYMAP uni(3 , h , e);
MYMAP bi(3 , h , e);
MYMAP tri(3 , h , e);
{
size_t spaces[3];
for(size_t i = 0 ; i < total; ++i){
prev = i;
unsigned short int count = 0;
unsigned short int tab_count = 0;
bool error = false;
for(; buf[i] != '\n'; ++i){ //get freq
if (buf[i] == '\t'){
if (tab_count < 2){
buf[i] = '=';
}
else{
spaces[count] = i;
++count;
};
++tab_count;
}
else if(buf[i] == ' '){ //you can't use space
buf[i] = '_';
}
else if(buf[i] == ':'){ //SPLITTER is ':'
if (count==3){
error = true;
}
else{
spaces[count] = i;
++count;
};
};
};
if (count!=3 or error)
continue;
buf[spaces[0]] = ' ';
buf[spaces[1]] = ' ';
const size_t end_1 = spaces[0];
const size_t end_2 = spaces[1];
const size_t end_3 = spaces[2];
const size_t tail = i;
std::pair<size_t , size_t> word1(prev, end_1);
std::pair<size_t , size_t> word2(end_1+1 , end_2);
std::pair<size_t , size_t> bi1(prev, end_2);
std::pair<size_t , size_t> word3(end_2+1 , end_3);
std::pair<size_t , size_t> bi2(end_1+1, end_3);
std::pair<size_t , size_t> tri1(prev, end_3);
buf[tail] = '\0';
const unsigned long freq = atoi(&buf[end_3]);
add(uni, word1, freq);
add(uni, word2, freq);
add(uni, word3, freq);
add(bi, bi1, freq);
add(bi, bi2, freq);
add(tri, tri1, freq);
};
}
printout(1, uni, out_folder, buf, 0);
printout(2, bi, out_folder, buf, 10000000);
printout(3, tri, out_folder, buf, 10000000);
};
strtodI(CONST char *s, char **sp, double *dd)
#endif
{
static FPI fpi = { 53, 1-1023-53+1, 2046-1023-53+1, 1, SI };
ULong bits[2], sign;
Long exp;
int j, k;
U *u;
k = strtodg(s, sp, &fpi, &exp, bits);
u = (U*)dd;
sign = k & STRTOG_Neg ? 0x80000000L : 0;
switch(k & STRTOG_Retmask) {
case STRTOG_NoNumber:
dval(&u[0]) = dval(&u[1]) = 0.;
break;
case STRTOG_Zero:
dval(&u[0]) = dval(&u[1]) = 0.;
#ifdef Sudden_Underflow
if (k & STRTOG_Inexact) {
if (sign)
word0(&u[0]) = 0x80100000L;
else
word0(&u[1]) = 0x100000L;
}
break;
#else
goto contain;
#endif
case STRTOG_Denormal:
word1(&u[0]) = bits[0];
word0(&u[0]) = bits[1];
goto contain;
case STRTOG_Normal:
word1(&u[0]) = bits[0];
word0(&u[0]) = (bits[1] & ~0x100000) | ((exp + 0x3ff + 52) << 20);
contain:
j = k & STRTOG_Inexact;
if (sign) {
word0(&u[0]) |= sign;
j = STRTOG_Inexact - j;
}
switch(j) {
case STRTOG_Inexlo:
#ifdef Sudden_Underflow
if ((u->L[_0] & 0x7ff00000) < 0x3500000) {
word0(&u[1]) = word0(&u[0]) + 0x3500000;
word1(&u[1]) = word1(&u[0]);
dval(&u[1]) += ulp(&u[1]);
word0(&u[1]) -= 0x3500000;
if (!(word0(&u[1]) & 0x7ff00000)) {
word0(&u[1]) = sign;
word1(&u[1]) = 0;
}
}
else
#endif
dval(&u[1]) = dval(&u[0]) + ulp(&u[0]);
break;
case STRTOG_Inexhi:
dval(&u[1]) = dval(&u[0]);
#ifdef Sudden_Underflow
if ((word0(&u[0]) & 0x7ff00000) < 0x3500000) {
word0(&u[0]) += 0x3500000;
dval(&u[0]) -= ulpdown(u);
word0(&u[0]) -= 0x3500000;
if (!(word0(&u[0]) & 0x7ff00000)) {
word0(&u[0]) = sign;
word1(&u[0]) = 0;
}
}
else
#endif
dval(&u[0]) -= ulpdown(u);
break;
default:
dval(&u[1]) = dval(&u[0]);
}
break;
case STRTOG_Infinite:
word0(&u[0]) = word0(&u[1]) = sign | 0x7ff00000;
word1(&u[0]) = word1(&u[1]) = 0;
if (k & STRTOG_Inexact) {
if (sign) {
word0(&u[1]) = 0xffefffffL;
word1(&u[1]) = 0xffffffffL;
}
else {
word0(&u[0]) = 0x7fefffffL;
word1(&u[0]) = 0xffffffffL;
}
}
break;
case STRTOG_NaN:
u->L[0] = (u+1)->L[0] = d_QNAN0;
u->L[1] = (u+1)->L[1] = d_QNAN1;
break;
case STRTOG_NaNbits:
word0(&u[0]) = word0(&u[1]) = 0x7ff00000 | sign | bits[1];
word1(&u[0]) = word1(&u[1]) = bits[0];
}
return k;
}
