//-----------------------UART_ConvertDistance-----------------------
// Converts a 32-bit distance into an ASCII string
// Input: 32-bit number to be converted (resolution 0.001cm)
// Output: store the conversion in global variable String[10]
// Fixed format 1 digit, point, 3 digits, space, units, null termination
// Examples
// 4 to "0.004 cm"
// 31 to "0.031 cm"
// 102 to "0.102 cm"
// 2210 to "2.210 cm"
//10000 to "*.*** cm" any value larger than 9999 converted to "*.*** cm"
void UART_ConvertDistance(unsigned long n){
// as part of Lab 11 implement this function
if (n >= 10000) {
strcpy((char *) String, "*.***");
}
else {
String[0] = parseDigit(n,1000,1); // thousands digit
String[1] = '.';
String[2] = parseDigit(n,100,1); // hundreds digit
String[3] = parseDigit(n,10,1); // tens digit
String[4] = parseDigit(n, 1,1); // ones digit
}
strcat((char *) String, " cm");
}
//-----------------------UART_ConvertUDec-----------------------
// Converts a 32-bit number in unsigned decimal format
// Input: 32-bit number to be transferred
// Output: store the conversion in global variable String[10]
// Fixed format 4 digits, one space after, null termination
// Examples
// 4 to " 4 "
// 31 to " 31 "
// 102 to " 102 "
// 2210 to "2210 "
//10000 to "**** " any value larger than 9999 converted to "**** "
void UART_ConvertUDec(unsigned long n){
// as part of Lab 11 implement this function
if (n >= 10000) {
strcpy((char *) String, "****");
}
else {
String[0] = parseDigit(n,1000,0); // thousands digit
String[1] = parseDigit(n,100,0); // hundreds digit
String[2] = parseDigit(n,10,0); // tens digit
String[3] = parseDigit(n, 1,0); // ones digit
}
String[4] = 0x20; // add a space at the end
String[5] = 0; // null termination
}
int parser::parseFuncArgs(char *p, int &iStartParse, subexp *pSubExp, float *pArgs, int &iArgsNum, variable_scope &varScope)
{
iStartParse++;
int iSubIndex = floatToInt(parseDigit(p,iStartParse,true));
// Implement unary minus here
for (int i = 0; pSubExp[iSubIndex].exp[i]; i++)
{
// Parse digit
if (isDigit(pSubExp[iSubIndex].exp[i]))
{
pArgs[iArgsNum] = parseDigit(pSubExp[iSubIndex].exp, i, true);
}
// Parse unary minus
else if (pSubExp[iSubIndex].exp[i]=='-' && pSubExp[iSubIndex].exp[i+1] && isDigit(pSubExp[iSubIndex].exp[i+1]))
{
i++;
pArgs[iArgsNum] = parseDigit(pSubExp[iSubIndex].exp, i, true, true);
}
// Parse next arg
else if (pSubExp[iSubIndex].exp[i]==',')
{
iArgsNum += 1;
continue;
}
// Parse build in func
else if (isChar(pSubExp[iSubIndex].exp[i]) && isFunc(pSubExp[iSubIndex].exp, i))
{
pArgs[iArgsNum] = pSubExp[parseBuildInFunc(pSubExp[iSubIndex].exp, i, pSubExp, varScope, true)].result;
}
// Parse variable
else if (isChar(pSubExp[iSubIndex].exp[i]))
{
pArgs[iArgsNum] = varScope.vScope[parseVariable(pSubExp[iSubIndex].exp, i, varScope, false)].getValue();
}
// Parse sub string
else if (pSubExp[iSubIndex].exp[i]=='$')
{
pArgs[iArgsNum] = pSubExp[parseSubExp(pSubExp[iSubIndex].exp, i, pSubExp, varScope, true)].result;
}
}
iArgsNum += 1;
return iSubIndex;
}
int parser::parseSubExp(char *p, int &iStartParse, subexp *pSubExp, variable_scope &varScope, bool bReturnParseIndex)
{
int iCurSub;
raw_materials rawMat;
iStartParse++;
iCurSub = floatToInt(parseDigit(p, iStartParse, bReturnParseIndex));
rawMat.getTokens(pSubExp[iCurSub].exp, pSubExp, varScope);
pSubExp[iCurSub].result = rawMat.getResult();
// we return index of SubExpression which was used
return iCurSub;
}
cbool parseNumber( parse *p, unsigned *n )
{
unsigned i = 0;
char s[300];
while ( parseDigit( p, &(s[i]) )
&& assign ( i++ )
);
return ( i > 0
&& assign( s[i] = '\0' )
&& assign( *n = atoi( s ) )
);
}
static kint_t _kstrtoll(const char *p, char (*parseDigit)(char), int base)
{
long long tmp = 0, prev = 0;
char c;
for (; (c = *p) != 0; ++p) {
if(c == '_') continue;
c = parseDigit(c);
if(c == -1)
break;
tmp = tmp * base + c;
if(tmp < prev) {
/* Overflow!! */
return 0;
}
prev = tmp;
}
return (kint_t) tmp;
}
bool isNumber(const char *s) {
// empty space
// +/-
// [0123456789]
// .
// [0123456789]
// e/E
// [0123456789]
// empty space
// empty string should be treated as false?
if (s == nullptr || *s == 0) return false;
// process empty space
parseSpace(s);
if (*s == 0) return false; // empty string
parseSign(s);
if (*s == 0) return false;
if (parseDigit(s) == 0) {
if (!parseDot(s)) return false;
if (parseDigit(s) == 0) return false;
if (parseSpace(s) > 0) return *s == 0;
if (*s == 0) return true;
if (!parseExp(s)) return false;
parseSign(s);
if (parseDigit(s) == 0) return false;
parseSpace(s);
return *s == 0;
} else {
if (parseSpace(s) > 0) return *s == 0;
if (*s == 0) return true;
if (parseDot(s)) {
parseDigit(s);
if (parseSpace(s) > 0) return *s == 0;
if (*s == 0) return true;
if (!parseExp(s)) return false;
parseSign(s);
if (parseDigit(s) == 0) return false;
parseSpace(s);
return *s == 0;
} else if (parseExp(s)) {
parseSign(s);
if (parseDigit(s) == 0) return false;
parseSpace(s);
return *s == 0;
} else {
return false;
}
}
}
vector<uint8_t> Immediate::parse(std::string& in, ImmediateEncoding base)
{
string::iterator it_fwd;
string::reverse_iterator it;
vector<uint8_t> out;
int padding = 0;
int bytes_written=0;
unsigned int tmp = 0;
int counter = 1;
std::string intermediate;
//pad with zero if not an even mult
switch(base)
{
case BASE_HEX:
strToLowerCase(in);
if (in.length() % 2 != 0)
in.insert(0,1,'0');
//skip the delmiting commas.
out.resize((in.length()) / 2);
//in.resize(4);
for (it = in.rbegin();it!=in.rend();++it)
{
out[bytes_written] = parseDigit(*it) | parseDigit(*++it) << 4 ;
bytes_written++;
}
break;
case BASE_BIN:
strToLowerCase(in);
padding = 8 - (in.length() % 8);
if (padding != 8)
in.insert(0, padding, (char)in[0]);
out.resize(in.length() / 8);
for (it = in.rbegin();it != in.rend();)
{
for (int i = 0; i < 8;i++)
{
out[bytes_written] |= parseDigit(*it) << i;
it++;
}
}
break;
case BASE_ASC:
out.resize(in.length() - 2);
trim(in, '\'');
for (it_fwd = in.begin(); it_fwd < in.end();it_fwd++)
{
out[bytes_written] = (uint8_t)*it_fwd;
bytes_written++;
}
break;
case BASE_DEC:
intermediate = in.at(0) == '-'? in.substr(1,-1): in;
for (it= intermediate.rbegin();it < intermediate.rend();it++){
tmp = tmp + (counter) * parseDigit(*it);
counter*=10;
}
if (in.at(0) == '-')
tmp = (tmp * -1) & 0xFFFF;
do {
out.push_back((uint8_t)(tmp & 0xFF));
tmp >>= 8;
} while (tmp > 0);
default:
break;
//clear out any zero-padding to make sure it fits in smallest byte count.
//zero bytes isn't valid though...
}
while ((out.size() > 1) && out.back() == (out.back() >= 0x80 ? 0xFF : 0x00))
out.pop_back();
return out;
}
static KMETHOD TokenFunc_ExtendedIntLiteral(KonohaContext *kctx, KonohaStack *sfp)
{
kTokenVar *tk = (kTokenVar *)sfp[1].asObject;
const char *source = kString_text(sfp[2].asString);
const char *start = source, *end;
int c = *source++;
/*
* DIGIT = 0-9
* DIGITS = DIGIT | DIGIT DIGITS
* HEX = 0-9a-fA-F
* HEXS = HEX | HEX HEXS
* BIN = 0 | 1
* BINS = BIN | BIN BINS
* TAG = "0x" | "0b"
* HEXINT = ("0x" | "0X") HEXS
* INT = DIGITS | HEXS | BINS
*/
int base = 10;
bool isFloat = false;
char (*parseDigit)(char) = parseDecimalDigit;
if(c == '0') {
c = *source++;
switch (c) {
case 'b':
base = 2; parseDigit = parseBinaryDigit; break;
case 'x':
base = 16; parseDigit = parseHexDigit; break;
case '0':case '1':case '2':case '3':
case '4':case '5':case '6':case '7':
base = 8; parseDigit = parseOctalDigit;
break;
default:
source--;
break;
}
}
for (; (c = *source) != 0; ++source) {
if(c == '_') continue;
if(parseDigit(c) == -1)
break;
}
/*
* DIGIT = 0-9
* DIGITS = DIGIT | DIGIT DIGITS
* INT = DIGIT | DIGIT1-9 DIGITS
* FLOAT = INT
* | INT FRAC
* | INT EXP
* | INT FRAC EXP
* FRAC = "." digits
* EXP = E digits
* E = 'e' | 'e+' | 'e-' | 'E' | 'E+' | 'E-'
*/
if(base != 10 && c != '.' && c != 'e' && c != 'E') {
goto L_emit;
}
if(c == '.') {
isFloat = true;
source++;
for (; (c = *source) != 0; ++source) {
if(c == '_') continue;
if(parseDecimalDigit(c) == -1)
break;
}
}
if(c == 'e' || c == 'E') {
isFloat = true;
c = *(++source);
if(!('0' <= c && c <= '9') && !(c == '+' || c == '-')) {
source--;
goto L_emit;
}
if(c == '+' || c == '-') {
c = *source++;
}
for (; (c = *source) != 0; ++source) {
if(c == '_') continue;
if(parseDecimalDigit(c) == -1)
break;
}
}
L_emit:;
if(IS_NOTNULL(tk)) {
/* skip unit */
for (; (c = *source) != 0; ++source) {
if(c == '_') continue;
if(!isalpha(c))
break;
}
end = source;
KFieldSet(tk, tk->text, KLIB new_kString(kctx, OnField, start, end - start, StringPolicy_ASCII));
tk->tokenType = isFloat ? KSymbol_("$Float") : TokenType_Number;
}
KReturnUnboxValue(source - start);
}
