Macintosh-SW/mpw
1
0
Fork 0
mirror of https://github.com/ksherlock/mpw.git synced 2024-11-22 00:32:44 +00:00
Code Issues Projects Releases Wiki Activity

remove old sane code (moved to libsane).

Browse Source
This commit is contained in:
Kelvin Sherlock 2018-01-01 14:13:30 -05:00
parent 8c38175492
commit 2eb90481bc
1 changed files with 0 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
toolbox/saneparser.rl
View File

@ -1,293 +0,0 @@
/*
* Copyright (c) 2013, Kelvin W Sherlock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "sane.h"
#include <string>
namespace SANE {
/*
* %{} is a final transition. fpc points to the next character
* %!{} is a final transition to an error state. fpc " " " "
*
*/
%%{
machine fpstr;
action check { checkpoint = fpc; }
nantype =
'('
digit* ${ nantype = nantype * 10 + fc - '0'; }
')'
$!{ nantype = 0; }
%check
;
nan = 'NAN'i
>{ nan = true; }
%check
%!check
nantype?
;
infinity = 'INF'i
>{ nan = true; }
%{ nan = false; infinity = true; checkpoint = fpc; }
%!{ nan = false; infinity = true; checkpoint = fpc; };
exponent =
[eE]
[+\-]? ${ if (fc == '-') negative_exp = true; }
digit+ ${ exp = exp * 10 + fc - '0'; }
%check
%!check
;
significand =
(
(
digit+ ${
// don't push leading 0s
if (fc != '0' || siga.size())
siga.push_back(fc);
}
( '.' digit* ${ sigb.push_back(fc); })?
)
|
(
'.'
digit+ ${ sigb.push_back(fc); }
)
)
%check
%!check
;
finite_number = significand exponent?;
unsigned_decimal = finite_number | infinity | nan;
left_decimal =
[+\-]? ${ if (fc == '-') negative = true; }
unsigned_decimal
;
decimal_number = [ \t]* left_decimal;
main := decimal_number;
}%%
std::string normalize(std::string &a, std::string &b, int &exponent)
{
int pos;
// 1 = 1e0 10 = 1e1
// 12 = 12e0
// 123 = 123e0
// 1.1 = 11e-1
// 0.1 = 1e-1
// remove trailing 0s
while (b.size() && b.back() == '0')
b.pop_back();
int bits = 0;
if (a.length()) bits |= 0x01;
if (b.length()) bits |= 0x02;
std::string out;
switch(bits)
{
case 0x00:
// should never happen...
break;
case 0x01:
// a only.
// remove trailing 0s and add 1 exp for each.
while (a.length() && a.back() == '0')
{
a.pop_back();
exponent++;
}
out = a;
break;
case 0x02:
// b only.
//.001 = e1-3
exponent -= b.length();
pos = b.find_first_not_of('0');
out = b.substr(pos);
break;
case 0x03:
// a and b
// 10.01 = 1001e-2
exponent -= b.length();
out = a;
out += b;
break;
}
if (out.empty()) out = "0";
return out;
}
void str2dec(const std::string &s, uint16_t &index, decimal &d, uint16_t &vp)
{
%%write data;
bool infinity = false;
bool nan = false;
int nantype = 0;
bool negative = false;
bool negative_exp = false;
int exp = 0;
std::string siga, sigb;
if (index >= s.size()) return;
/*
char *p = s.c_str();
char *pe = p + s.size();
char *eof = pe;
char *checkpoint = p;
*/
auto p = s.begin();
auto checkpoint = s.begin();
auto pe = s.end();
auto eof = s.end();
int cs;
p += index;
%%write init;
%%write exec;
d.sgn = negative ? 1 : 0;
if (infinity)
{
d.sig = "I";
}
else if (nan)
{
d.sig = "N";
if (nantype)
{
const char *hexstr = "0123456789abcdef";
// 4-byte hex
d.sig.push_back(hexstr[(nantype >> 24) & 0xff]);
d.sig.push_back(hexstr[(nantype >> 16) & 0xff]);
d.sig.push_back(hexstr[(nantype >> 8) & 0xff]);
d.sig.push_back(hexstr[(nantype >> 0) & 0xff]);
}
}
else
{
d.sig = normalize(siga, sigb, exp);
d.exp = negative_exp ? -exp : exp;
}
vp = cs != fpstr_error;
index = checkpoint - s.begin();
return;
#if 0
printf("%s\n", str);
bool valid = cs != fpstr_error;
int index = checkpoint - str;
printf("infinity: %d\n", infinity);
printf(" nan: %d\n", nan);
printf(" nantype: %d\n", nantype);
if (negative_exp) exp = -exp;
printf(" exp: %d\n", exp);
printf("negative: %d\n", negative);
printf(" sig: %s.%s\n", siga.c_str(), sigb.c_str());
printf(" valid: %d\n", valid);
printf(" index: %d\n", index);
printf("\n");
/*
* now we need to normalize the significand / exponent
* 1.2 e0 -> 12 e-1
* 1000 e0 -> 1 e 3
*/
std::string sig = normalize(siga, sigb, exp);
printf("normalized: %s e %d\n", sig.c_str(), exp);
#endif
}
} // namespace
#ifdef MAIN
#include <cstdio>
int main(int argc, char **argv)
{
for (int i = 1; i < argc; ++i)
{
std::string s = argv[i];
SANE::decimal d;
short index = 0;
short valid = 0;
SANE::str2dec(s, index, d, valid);
printf("index: %d\n", index);
printf("valid: %d\n", valid);
printf(" sign: %d\n", d.sgn);
printf(" exp: %d\n", d.exp);
printf(" sig: %s\n", d.sig.c_str());
printf("\n");
}
}
#endif