void Opcode8040::_run() {
Logger::debug("SCRIPT") << "[8040] [*] op_bwand" << std::endl;
auto bValue = _script->dataStack()->pop();
auto aValue = _script->dataStack()->pop();
if (!aValue.isNumber() || !bValue.isNumber()) {
_error(std::string("op_bwand: invalid argument types: ") + aValue.typeName() + " bwand " +
bValue.typeName());
}
_script->dataStack()->push(aValue.toInteger() & bValue.toInteger());
}
void Opcode803DHandler::_run()
{
Logger::debug("SCRIPT") << "[803D] [*] op_mod %" << std::endl;
auto bValue = _vm->dataStack()->pop();
auto aValue = _vm->dataStack()->pop();
if (!aValue.isNumber() || !bValue.isNumber())
{
_error(std::string("op_mod: invalid argument types: ") + aValue.typeName() + " % " + bValue.typeName());
}
_vm->dataStack()->push(aValue.toInteger() % bValue.toInteger());
}
int typeSize(refObject type)
{ switch (toHook(car(type)))
{ case arrayHook:
{ type = cdr(type);
return toInteger(car(type)) * typeSize(cadr(type)); }
case char0Hook:
{ return sizeof(char0Type); }
case char1Hook:
{ return sizeof(char1Type); }
case int0Hook:
{ return sizeof(int0Type); }
case int1Hook:
{ return sizeof(int1Type); }
case int2Hook:
{ return sizeof(int2Type); }
case nullHook:
case referHook:
case rowHook:
{ return sizeof(pointerType); }
case procHook:
{ return sizeof(procType); }
case real0Hook:
{ return sizeof(real0Type); }
case real1Hook:
{ return sizeof(real1Type); }
case skoHook:
case varHook:
{ return typeSize(cadr(type)); }
case strTypeHook:
{ return toInteger(cadddr(type)); }
case tupleHook:
{ int slotAlign;
refObject slotType;
int tupleAlign = 1;
int tupleSize = 0;
type = cdr(type);
while (type != nil)
{ slotType = car(type);
slotAlign = typeAlign(slotType);
tupleAlign = (slotAlign > tupleAlign ? slotAlign : tupleAlign);
tupleSize += typeSize(slotType);
tupleSize += rounder(tupleSize, slotAlign);
type = cddr(type); }
return tupleSize + rounder(tupleSize, tupleAlign); }
case voidHook:
{ return sizeof(voidType); }
default:
{ fail("Type has undefined size in typeSize!"); }}}
package_local boolean compileLiteral(String name) {
int num = 0, sign = -1, idx = 0, len = strlen(name);
if (charAt(name, 0) == '-') {
sign = idx = 1;
}
int decimal = -10000;
while (idx < len) {
int chr = charAt(name, idx++);
if (chr == '.') {
decimal = 1;
} else {
int digit = '0' - chr;
if (digit > 0 || digit < -9) return false; // NaN
num = (num * 10) + digit;
decimal *= 10;
}
}
if (decimal < 0) {
compilePushWord(name, toInteger(sign * num));
} else {
double real = (sign * num) / (double) decimal;
compilePushWord(name, toDouble(real));
}
return true;
}
static status
addIntItem(IntItem ii, Int change)
{ Int ival;
long val;
char buf[100];
CharArray ctmp;
Int low, high;
if ( (ival = toInteger(ii->value_text->string)) )
val = valInt(ival);
else
val = 0;
val += valInt(change);
if ( (low=getLowIntItem(ii)) )
val = max(val, valInt(low));
if ( (high = getHighIntItem(ii)) )
val = min(val, valInt(high));
sprintf(buf, "%ld", val);
ctmp = CtoScratchCharArray(buf);
displayedValueTextItem((TextItem)ii, ctmp);
doneScratchCharArray(ctmp);
applyTextItem((TextItem)ii, OFF);
succeed;
}
long LuaInterface::popInteger()
{
assert(hasIndex(-1));
long v = toInteger(-1);
pop();
return v;
}
static ssize_t write(struct file *file, const char __user *buffer, size_t size, loff_t *offset) {
ssize_t result;
char *valueAsString;
if (!(valueAsString = kzalloc(size + 1, GFP_KERNEL))) {
return -ENOMEM;
}
// Copy data from user to kernel memory
if (!copy_from_user(valueAsString, buffer, size)) {
//unsigned long value = simple_strtoul(buffer, NULL, 0);
unsigned long value = toInteger(buffer);
if (!(value >= 0 && value <= 255)) {
return -ERANGE;
}
iowrite8((unsigned char)value, ledsIOBase);
result = size;
} else {
printk(KERN_WARNING MODULE_LABEL "Error copying data to kernel memory!");
result = /* Error copying data! */ -EFAULT;
}
kfree(valueAsString);
return result;
}
string Numbers::toHex(int number) // Returns a string representation of integer in hex form.
{
string ret_str; // Return string handle.
string num_str; // Number string handle.
if (number < 0) ret_str = "-0x"; else ret_str = "0x";
while (number >= 16) // Collect all the hexa-decimal digits.
{
int rem = number % 16; // Get the hexa-decimal digit.
number /= 16;
if (rem > 9) num_str += (char) ('A' + rem - 10); // Add the letter hexa-decimal digit if more than 9.
else num_str += toInteger(rem); // Add only the digit.
}
if (number > 9) num_str += (char) ('A' + number - 10); // Add the letter hexa-decimal digit if more than 9.
else num_str += Numbers::toInteger(number);
string cp_str = "";
for (register int cnt = num_str.length() - 1; cnt >= 0; cnt--) cp_str += num_str[cnt]; // Reverse the string.
num_str = cp_str; // Assign the reverse string.
return (ret_str += num_str); // Return the final string.
}
bool toUnsigned(const std::u16string& value, unsigned int& output)
{
int n;
if (toInteger(value, n) && 0 <= n) {
output = n;
return true;
}
return false;
}
double toScalar() const
{
if (isInteger())
return toInteger();
if (isDouble())
return toDouble();
qWarning("can't cast term to scalar");
return 0.0;
}
static Variant idateImpl(const String& format, int64_t timestamp) {
if (format.size() != 1) {
throw_invalid_argument("format: %s", format.data());
return false;
}
auto dt = req::make<DateTime>(timestamp, false);
int64_t ret = dt->toInteger(*format.data());
if (ret == -1) return false;
return ret;
}
void ScriptInterpreter::setKernelVar(int index, const ScriptValue &value) {
debugCN(kDebugScript, "ScriptInterpreter::setKernelVar() index = %d\n", index);
if (index > _kernelVarsMax) {
debugCN(kDebugScript, "ScriptInterpreter::setKernelVar() Invalid kernel var index %d!\n", index);
return;
}
debugCN(kDebugScript, "ScriptInterpreter::setKernelVar() name = %s\n", _kernelVars[index].desc);
ScriptKernelVariable var = _kernelVars[index].var;
switch (var) {
case kKernelTrigger:
_vm->_kernel->trigger = toInteger(value);
debugCN(kDebugScript, "kKernelTrigger -> %d\n", toInteger(value));
break;
case kKernelTriggerMode:
_vm->_kernel->triggerMode = (KernelTriggerType)toInteger(value);
debugCN(kDebugScript, "kKernelTrigger -> %d\n", toInteger(value));
break;
case kKernelContinueHandlingTrigger:
_vm->_kernel->daemonTriggerAvailable = (toInteger(value) != 0);
debugCN(kDebugScript, "kKernelContinueHandlingTrigger -> %d\n", toInteger(value));
break;
case kGameNewRoom:
_vm->_kernel->newRoom = toInteger(value);
debugCN(kDebugScript, "kGameNewRoom -> %d\n", toInteger(value));
break;
case kPlayerCommandReady:
// TODO
debugCN(kDebugScript, "kPlayerCommandReady -> %d\n", toInteger(value));
break;
default:
debugCN(kDebugScript, "ScriptInterpreter::setKernelVar() Invalid kernel var %d!\n", var);
//g_system->delayMillis(2000);
}
}
double JSValue::toLength(ExecState* exec) const
{
// ECMA 7.1.15
// http://www.ecma-international.org/ecma-262/6.0/#sec-tolength
double d = toInteger(exec);
if (d <= 0)
return 0.0;
if (std::isinf(d))
return 9007199254740991.0; // 2 ** 53 - 1
return std::min(d, 9007199254740991.0);
}
void esViewportTearEdges(int sx, int sy, float desiredAspectRatio)
{
double w = double(sx);
double h = double(sy);
double curAspect = w/h;
if( curAspect < desiredAspectRatio )
{
double desiredHeight = w/desiredAspectRatio;
double d = 1.0 - desiredHeight/h;
double margin = 0.5 * d;
glViewport( 0, toInteger(margin*h), toInteger(1.0*w), toInteger((1.0 - (2.0*margin))*h) );
}
else if( curAspect > desiredAspectRatio )
{
double desiredWidth = h*desiredAspectRatio;
double d = 1.0 - desiredWidth/w;
double margin = 0.5 * d;
glViewport( toInteger(margin*w), 0, toInteger((1.0 - (2.0*margin))*w), toInteger(h) );
}
else
{
glViewport( 0, 0, sx, sy );
}
}
Number Number::clone() const {
switch (type()) {
case NumberType::Integer:
return Integer(toInteger());
case NumberType::Double:
return Double(toDouble());
case NumberType::Float:
return Float(toFloat());
case NumberType::Boolean:
return Boolean(toBoolean());
}
throw std::runtime_error(MakeString()<<"Could not clone number "<<toString());
}
static Elevation
getConvertElevation(Any receiver, Any val)
{ Int i;
Elevation e;
if ( (e= getLookupElevation(receiver, val,
DEFAULT, DEFAULT, DEFAULT,
DEFAULT, DEFAULT, DEFAULT)) )
return e;
if ( (i = toInteger(val)) )
answer(answerObject(ClassElevation, i, i, EAV));
fail;
}
int typeAlign(refObject type)
{ switch (toHook(car(type)))
{ case arrayHook:
{ return typeAlign(caddr(type)); }
case char0Hook:
{ return alignof(char0Type); }
case char1Hook:
{ return alignof(char1Type); }
case int0Hook:
{ return alignof(int0Type); }
case int1Hook:
{ return alignof(int1Type); }
case int2Hook:
{ return alignof(int2Type); }
case nullHook:
case referHook:
case rowHook:
{ return alignof(pointerType); }
case procHook:
{ return alignof(procType); }
case real0Hook:
{ return alignof(real0Type); }
case real1Hook:
{ return alignof(real1Type); }
case skoHook:
case varHook:
{ return typeAlign(cadr(type)); }
case strTypeHook:
{ return toInteger(caddr(type)); }
case tupleHook:
{ int maxAlign = 1;
type = cdr(type);
while (type != nil)
{ int align = typeAlign(car(type));
maxAlign = (align > maxAlign ? align : maxAlign);
type = cddr(type); }
return maxAlign; }
case voidHook:
{ return alignof(voidType); }
default:
{ fail("Type has undefined alignment in typeAlign!"); }}}
inline ber::Value Value::toBerValue() const
{
switch(type().value())
{
case ParameterType::Integer:
return ber::Value(toInteger());
case ParameterType::Real:
return ber::Value(toReal());
case ParameterType::String:
return ber::Value(toString());
case ParameterType::Octets:
return ber::Value(toOctets());
case ParameterType::Boolean:
return ber::Value(toBoolean());
}
return ber::Value();
}
void GraphTranslator::translate(const value::Map& buffer)
{
const value::Map& init = toMapValue(buffer);
mNodeNumber = toInteger(init.get("number"));
if (mNodeNumber <= 0) {
throw utils::ArgError("GraphTranslator: bad node number");
} else {
BoolArray::extent_gen extents;
mGraph.resize(extents[mNodeNumber][mNodeNumber]);
}
if (init.exist("prefix")) {
mPrefix = toString(init.get("prefix"));
if (mPrefix.empty()) {
throw utils::ArgError("GraphTranslator: bad prefix");
}
}
if (init.exist("port")) {
mPort = toString(init.get("port"));
}
std::string adjmat;
if (init.exist("adjacency matrix file")) {
const value::Map& matrix = init.getMap("adjacency matrix file");
std::string file =
std::string(utils::Path::path().getExternalPackageDataFile(
matrix.getString("package"), matrix.getString("file")));
std::ifstream File(file.c_str());
std::string ligne;
while (getline(File,ligne)) {
adjmat += ligne.c_str();
adjmat += "\n";
}
} else {
adjmat = init.getString("adjacency matrix");
}
std::string classes;
if (init.exist("classes file")) {
std::string file;
const value::Map& classesFile = init.getMap("classes file");
file =
std::string(utils::Path::path().getExternalPackageDataFile(
classesFile.getString("package"),
classesFile.getString("file")));
std::ifstream File(file.c_str());
std::string ligne;
while (getline(File,ligne)) {
classes += ligne.c_str();
classes += "\n";
}
}
else {
classes = init.getString("classes");
}
typedef boost::tokenizer < boost::char_separator < char > > tokenizer;
boost::char_separator<char> sep(" \n\t\r");
{
tokenizer tok(adjmat, sep);
size_type i = 0, j = 0;
for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) {
if (j==mNodeNumber)
throw utils::ArgError("GraphTranslator: bad node number in matrix");
mGraph[j][i] = ((*it) == "1");
++i;
if (i == mNodeNumber) {
i = 0;
++j;
}
}
if (j * mNodeNumber + i != mNodeNumber * mNodeNumber) {
throw utils::ArgError("GraphTranslator: bad node number in matrix");
}
}
{
tokenizer tok(classes, sep);
for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) {
mClass.push_back(*it);
}
}
if (mClass.size() != mNodeNumber) {
throw utils::ArgError("GraphTranslator: bad node number in class");
}
makeBigBang();
}
inline bool toInteger( signed int &i) { signed long l = 0; bool b=toInteger(l); i=l; return b; }
/* Zero-initialize to pacify gcc-4.2.1 by giving initial value */
inline bool toInteger(unsigned short &i) { unsigned long l = 0; bool b=toInteger(l); i=l; return b; }
int MiniPS::Tokenizer::yylex() {
int c=0; /* dummy initialization */
bool hi;
unsigned hv;
slen_t nest, len;
signed long l;
double d;
Real::metric_t metric;
char saved;
if (ungot==EOFF) return EOFF;
if (ungot!=NO_UNGOT) { c=ungot; ungot=NO_UNGOT; goto again; }
again_getcc:
c=in.vi_getcc();
again:
switch (c) {
case -1: eof:
return ungot=EOFF;
case '\n': case '\r': case '\t': case ' ': case '\f': case '\0':
goto again_getcc;
case '%': /* one-line comment */
while ((c=in.vi_getcc())!='\n' && c!='\r' && c!=-1) ;
if (c==-1) goto eof;
goto again_getcc;
case '{': case '[':
return '[';
case '}': case ']':
return ']';
case ')': goto err;
case '>':
if (in.vi_getcc()!='>') goto err;
return '>';
case '<':
if ((c=in.vi_getcc())==-1) { uf_hex: Error::sev(Error::EERROR) << "miniPS: unfinished hexstr" << (Error*)0; }
if (c=='<') return '<';
if (c=='~') Error::sev(Error::EERROR) << "miniPS: a85str unsupported" << (Error*)0;
tv.bb=&b; b.clear();
hi=true;
while (c!='>') {
if ((hv=b.hexc2n(c))!=16) {
if (hi) { b << (char)(hv<<4); hi=false; }
else { b.end_()[-1]|=hv; hi=true; }
} else if (!is_ps_white(c)) Error::sev(Error::EERROR) << "miniPS: syntax error in hexstr" << (Error*)0;
if ((c=in.vi_getcc())==-1) goto uf_hex;
}
/* This is correct even if an odd number of hex digits have arrived */
return '(';
case '(':
tv.bb=&b; b.clear();
nest=1;
while ((c=in.vi_getcc())!=-1) { redo:
if (c==')' && --nest==0) return '(';
if (c!='\\') { if (c=='(') nest++; b << (char)c; continue; }
/* read a backslash */
switch (c=in.vi_getcc()) {
case -1: goto uf_str;
case 'n': b << '\n'; break;
case 'r': b << '\r'; break;
case 't': b << '\t'; break;
case 'b': b << '\010'; break; /* \b and \a conflict between -ansi and -traditional */
case 'f': b << '\f'; break;
default:
if (c<'0' || c>'7') { b << (char)c; break; }
hv=c-'0'; /* read at most 3 octal chars */
if ((c=in.vi_getcc())==-1) goto uf_str;
if (c<'0' || c>'7') { b << (char)hv; goto redo; }
hv=8*hv+(c-'0');
if ((c=in.vi_getcc())==-1) goto uf_str;
if (c<'0' || c>'7') { b << (char)hv; goto redo; }
b << (char)(8*hv+(c-'0'));
} /* SWITCH */
} /* WHILE */
uf_str: Error::sev(Error::EERROR) << "miniPS: unfinished str" << (Error*)0;
case '/':
/* fall-through, b will begin with '/' */
default: /* /nametype, /integertype or /realtype */
tv.bb=&b; b.clear();
b.clear(); b << (char)c;
while ((c=in.vi_getcc())!=-1 && is_ps_name(c)) b << (char)c;
ungot=c==-1?EOFF:c;
if (b[0]=='/') return '/';
b.term0();
/* Dat: we don't support base-n number such as `16#100' == 256 in PostScript */
if (!toInteger(b, l)) { tv.i=l; return '1'; }
/* Dat: call toInteger _before_ toReal */
// if (!toReal(b, tv.d)) { fprintf(stderr,"%f;\n", tv.d); }
/* assert(tv.bb!=NULLP); */
len=b.getLength();
if (!toReal(b, d)) { /* tv.bb is also valid */
tv.r=new Real(d, b(), len);
return '.';
}
if (len>2 && (metric=Real::str2metric(b()+len-2))!=Real::ME_COUNT) {
saved=b[len-2];
b[len-2]='\0';
if (!toReal(b, d)) {
tv.r=new Real(d, b(), len-2);
tv.r->setMetric(metric);
return ':'; /* Real with metric */
}
b[len-2]=saved;
}
return 'E'; /* /nametype */
}
err:
Error::sev(Error::EERROR) << "miniPS: syntax error" << (Error*)0;
goto again_getcc; /* notreached */
}
void OpcodeComparisonHandler::_run()
{
Logger::debug("SCRIPT") << "[8033-8038] [*] " << _cmpOpcodeName() << std::endl;
auto bValue = _vm->dataStack()->pop();
auto aValue = _vm->dataStack()->pop();
int result = 0;
switch (aValue.type())
{
case VMStackValue::Type::INTEGER:
{
int arg1 = aValue.integerValue();
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(arg1, bValue.integerValue()); // INTEGER op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare(arg1, bValue.floatValue()); // INTEGER op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(arg1, bValue.toInteger()); // INTEGER op STRING (parsed as int)
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::FLOAT:
{
float arg1 = aValue.floatValue();
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(arg1, bValue.integerValue()); // FLOAT op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare(arg1, bValue.floatValue()); // FLOAT op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
float arg2 = 0.0;
try
{
arg2 = std::stof(bValue.stringValue());
}
catch (std::invalid_argument ex) { }
catch (std::out_of_range ex) { }
result = _compare(arg1, arg2); // FLOAT op STRING (parsed as float)
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::STRING:
{
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare(aValue.toInteger(), bValue.integerValue()); // STRING (as integer) op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
float arg1 = 0.0;
try
{
arg1 = std::stof(aValue.stringValue());
}
catch (std::invalid_argument ex) { }
catch (std::out_of_range ex) { }
result = _compare(arg1, bValue.floatValue()); // STRING (as float) op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(aValue.stringValue(), bValue.stringValue()); // STRING op STRING
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
case VMStackValue::Type::OBJECT:
{
switch (bValue.type())
{
case VMStackValue::Type::INTEGER:
{
result = _compare((int)aValue.toBoolean(), bValue.integerValue()); // OBJECT op INTEGER
break;
}
case VMStackValue::Type::FLOAT:
{
result = _compare((float)aValue.toBoolean(), bValue.floatValue()); // OBJECT op FLOAT
break;
}
case VMStackValue::Type::STRING:
{
result = _compare(aValue.toString(), bValue.stringValue()); // OBJECT op STRING - compare object name
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid right argument type: " + bValue.typeName());
}
}
break;
}
default:
{
_error(std::string() + _cmpOpcodeName() + ": invalid left argument type: " + aValue.typeName());
}
}
_vm->dataStack()->push(result);
}
void writingObject(refBuffer buffer, refObject object)
{ if (object == nil)
{ writeFormat(buffer, "[Nil]"); }
else
{ switch (tag(object))
{ case cellTag:
{ writeFormat(buffer, "[Cell %X]", object);
return; }
case characterTag:
{ writeCharacter(buffer, toCharacter(object));
return; }
case evenBinderTag:
{ writeFormat(buffer, "[EvenBinder %X]", object);
return; }
case hookTag:
{ writeFormat(buffer, "?%s", hookTo(object));
return; }
case hunkTag:
{ writeFormat(buffer, "[Hunk %X]", object);
return; }
case integerTag:
{ writeFormat(buffer, "%i", toInteger(object));
return; }
case jokerTag:
{ writeFormat(buffer, "[%s]", jokerTo(object));
return; }
case leftBinderTag:
{ writeFormat(buffer, "[LeftBinder %X]", object);
return; }
case markedTag:
{ writeFormat(buffer, "[...]");
return; }
case matchTag:
{ writeFormat(buffer, "[Match %X]", object);
return; }
case nameTag:
{ writeVisibleName(buffer, object);
return; }
case pairTag:
{ refObject pairs = object;
tag(object) = markedTag;
writeChar(buffer, '(');
writingObject(buffer, car(pairs));
pairs = cdr(pairs);
while (pairs != nil)
{ writeBlank(buffer);
writingObject(buffer, car(pairs));
pairs = cdr(pairs); }
writeChar(buffer, ')');
tag(object) = pairTag;
return; }
case realTag:
{ writeFormat(buffer, "%.17E", toReal(object));
return; }
case rightBinderTag:
{ writeFormat(buffer, "[RightBinder %X]", object);
return; }
case stringTag:
{ writeQuotedString(buffer, toRefString(object));
return; }
default:
{ writeFormat(buffer, "[Tag%i %X]", tag(object), object);
return; }}}}
bool
processConfigurationDetail( std::string detail, Logger& logger, int lineNumber )
{
std::string parameter, value;
if (extractParameterValue(detail, parameter, value))
{
if (parameter == "TrafficPercentage")
trafficPercentage = toInteger(value);
else if (parameter == "Name")
name = value;
else if (parameter == "NameAppendBytes")
nameAppendBytes = toInteger(value);
else if (parameter == "NameAppendSequenceNumber")
nameAppendSequenceNumber = toInteger(value);
else if (parameter == "MinSuffixComponents")
minSuffixComponents = toInteger(value);
else if (parameter == "MaxSuffixComponents")
maxSuffixComponents = toInteger(value);
else if (parameter == "ExcludeBefore")
excludeBefore = value;
else if (parameter == "ExcludeAfter")
excludeAfter = value;
else if (parameter == "ExcludeBeforeBytes")
excludeBeforeBytes = toInteger(value);
else if (parameter == "ExcludeAfterBytes")
excludeAfterBytes = toInteger(value);
else if (parameter == "ChildSelector")
childSelector = toInteger(value);
else if (parameter == "MustBeFresh")
mustBeFresh = toInteger(value);
else if (parameter == "NonceDuplicationPercentage")
nonceDuplicationPercentage = toInteger(value);
else if (parameter == "Scope")
scope = toInteger(value);
else if (parameter == "InterestLifetime")
interestLifetime = toInteger(value);
else if (parameter == "ExpectedContent")
expectedContent = value;
else
logger.log("Line "+toString(lineNumber)+" \t- Invalid Parameter='"+parameter+"'", false, true);
}
else
{
logger.log("Line "+toString(lineNumber)+" \t- Improper Traffic Configuration Line- "+detail, false, true);
return false;
}
return true;
}
int main(){
char **a;
char **userNo;
char **textContent;
int textContentCounter = 0;
int userNoCounter;
DDRB = 0xFF;
DDRD = 0b11111100;
DDRC = 0xFF;
DDRA = 0x00;
PORTA = 0x00;
initLCD();
USART_Init(78);
sei();
/************************* display Init message ********************/
LCDClear();
LCDPrint ("uC working");
_delay_ms(1000);
/*******************************************************************/
/****************************** GSM INIT ***************************/
okComplete = 0;
sendATCommand("at");
while (okComplete == 0);
if (okComplete == 1) {
/************** GSM initilization success ******************/
LCDClear();
LCDPrintLines ("GSM init.:", "successful");
/***********************************************************/
/****** Check for EEPROM value and reset it ****************/
/***********************************************************/
}else {
/************ GSM unsuccessful in initilization *************/
LCDClear();
LCDPrintLines ("GSM init.:", "failure");
_delay_ms(1000);
LCDClear();
LCDPrint ("System Halting...");
while (1);
/************************************************************/
}
_delay_ms(1000);
okComplete = 0;
sendATCommand("at+cmgda=\"DEL ALL\"");
while (okComplete == 0);
if (okComplete == 1){
LCDPrintLines ("message Delete", "successful");
} else if (okComplete == 2) {
LCDPrintLines ("can't del. msg.", "system halting...");
while (1);
}
_delay_ms(1000);
okComplete = 1;
/*******************************************************************/
whatIsGoingOn = NOTHING;
bufferCount = 0;
while (1){
if (okComplete == 1){
//OK received
LCDClear();
if (whatIsGoingOn == NOTHING){
LCDPrintLines("Vending Machine", "Code: vm001");
} else if (whatIsGoingOn == MESSAGE_SEND_SUCCESSFULLY){
LCDPrintLines("Product Dropped", "Thank You");
} else if (whatIsGoingOn == ERRORV){
LCDPrintLines ("Last Message:", "vmCode invalid");
} else if (whatIsGoingOn == ERRORP){
LCDPrintLines ("Last Message:", "itemCode invalid");
} else if (whatIsGoingOn == ERRORR){
LCDPrintLines ("Last Message:", "5 Retries Error");
} else if (whatIsGoingOn == ERRORO){
LCDPrintLines ("Last Message:", "Overfall");
} else if (whatIsGoingOn == ERRORA){
LCDPrintLines ("Last Message:", "unavail. product");
} else if (whatIsGoingOn == ERRORPA){
LCDPrintLines ("Last Message:", "und. pinCode len");
}
_delay_ms(1000);
if (whatIsGoingOn != NOTHING){
whatIsGoingOn = NOTHING;
okComplete = 1;
} else {
okComplete = 0;
}
} else if (okComplete == 2){
//ERROR Received
LCDClear();
LCDPrint ("Error Received");
_delay_ms(1000);
okComplete = 1;
}else if (msgReceived == 1){
//=CMTI Received
LCDClear();
LCDPrint ("msg rec @: ");
if (msgNumber1 == 255){
LCDData ((char)msgNumber);
} else {
LCDData ((char)msgNumber);
LCDData ((char)msgNumber1);
}
/******** read message and process on it **************/
//@1 set EEPROM
//@1 (set EEPROM) complete
okComplete = 0;
/************** try 5 times to read SMS ***************/
char repeatCounter = 2;
while (repeatCounter <= 5){
if (msgNumber1 == 255){
sendATCommand1("at+cmgr=", msgNumber);
} else {
sendATCommand2("at+cmgr=", msgNumber, msgNumber1);
}
while ((okComplete == 0)){
_delay_ms(200);
}
repeatCounter ++;
if (okComplete == 1 || repeatCounter > 5){
break;
} else {
okComplete = 0;
}
}
/******************************************************/
if (okComplete == 1){
/*********** AT+CMGR value received in buffer *********/
/*********** check for user number ********************/
if (authCheck){
userNo = split((char *) buffer, "\"", &userNoCounter);
if (equals(userNo[3], AUTH_PHONENO) == 0){
freeSplitedString(userNo, userNoCounter);
sendMessage1 (phoneNo, "Unknown number detected: ", userNo[3], 2);
msgReceived = 0;
msgNumber = -1;
msgNumber1 = -1;
continue;
}
freeSplitedString(userNo, userNoCounter);
}
/******************************************************/
/********** Check for message format ******************/
//@1 Spliting message
char *tempA2Lower;
a = split((char*) buffer, checkPattern, (int *)&counter);
tempA2Lower = toLower(a[2]);
free(a[2]);
a[2] = tempA2Lower;
textContent = split (a[2], " ", &textContentCounter);
pinCode = textContent[0];
vmCode = textContent[1];
productCode = textContent[2];
//@1 Complete
//@2 Check for 6 digit pinCode
if (length(pinCode) == 6){
//@3 check for vmMachine code
if (equals(vmCode, "vm001") == 1){
//@4 check for itemcode
char *subSubString;
subSubString = subString(productCode, 0, 1);
if (equals(subSubString, "a")){
char *subSubString2;
//@5 check for productValue
int productValue;
subSubString2 = subString(productCode, 1, 2);
productValue = toInteger(subSubString2);
if (productValue > 6 || productValue < 1){
/**** unavailable product ***********/
sendMessage1 (phoneNo, pinCode, "unavailable product", 2);
LCDPrintLines("Error: ", "unavailable product");
whatIsGoingOn = ERRORA;
/************************************/
} else {
/******** Every thing is correct drop the product *****/
//@6 drop the product and display in LCD
PORTC = (1 << (5 - (productValue - 1)));
LCDPrintLines("Dropping", "Product: ");
LCDPrint(subSubString2);
//@6 (drop the product and display in LCD) complete
//@7 start motor and count for 2 sec
unsigned int fallCounter = 0;
while ((!(bit_is_set(PINA, PA6))) && (!(bit_is_set(PINA, PA7)))) {
/******* find out time take here *******/
_delay_ms(1);
if (fallCounter > 2000){
break;
}
fallCounter++;
/****************************************/
}
//@8 stop the motor and check for time
PORTC = 0x00;
if (fallCounter >= 2000) {
/*********** overFall error **************/
sendMessage1 (phoneNo, pinCode, "Overfall error", 2);
LCDPrintLines("Error: ", "Overfall");
whatIsGoingOn = ERRORO;
/*****************************************/
} else {
/*********** success **************/
sendMessage (phoneNo, pinCode, 1);
LCDPrintLines("Drop: ", "successful");
whatIsGoingOn = MESSAGE_SEND_SUCCESSFULLY;
/*****************************************/
}
//@7 () Complete
/******************************************************/
}
free (subSubString2);
//@5 (Product value check) complete
} else {
/****** invalid vmCode *******/
sendMessage1 (phoneNo, pinCode, "productCode invalid", 2);
LCDPrintLines("Error: ", "productCode invalid");
whatIsGoingOn = ERRORP;
/*****************************/
}
free (subSubString);
//@4 (check for itemcode) complete
} else {
/****** invalid vmCode *******/
sendMessage1 (phoneNo, pinCode, "vmCode invalid", 2);
LCDPrintLines("Error: ", "vmCode invalid");
whatIsGoingOn = ERRORV;
/*****************************/
}
//@3 (check for vmMachine code) completed
} else {
/******* invalid pinCode *******/
sendMessage1 (phoneNo, pinCode, "pinCode invalid", 2);
LCDPrintLines("Error: und.", "pinCode length");
whatIsGoingOn = ERRORPA;
/*******************************/
}
//@2 (check for 6 digit pinCode) complete
freeSplitedString (a, counter);
freeSplitedString (textContent, textContentCounter);
/******************************************************/
/******************************************************/
} else if (okComplete == 2){
/**************** error reading sms *******************/
sendMessage (phoneNo, "couldn't read message from GSM modem", 2);
LCDPrintLines("Err Reading SMS", "5 Retries Error");
whatIsGoingOn = ERRORR;
/******************************************************/
}
/*********** delete the message **************/
if (msgNumber1 == 255) {
sendATCommand1("at+cmgd=", msgNumber);
} else {
sendATCommand2("at+cmgd=", msgNumber, msgNumber1);
}
/*********************************************/
//@2 reset EEPROM
//@2 (reset EEPROM) complete
_delay_ms(1000);
msgNumber = -1;
msgNumber1 = -1;
msgReceived = 0;
} else if (ringReceived == 1){
//RING received
LCDClear();
LCDPrintLines("Message Received:","dummy message");
_delay_ms(200);
/******** read message and process on it **************/
//@1 set EEPROM
//@1 (set EEPROM) complete
okComplete = 1;
strCpy((char*)newBuffer, (char*)buffer);
if (okComplete == 1){
/*********** AT+CMGR value received in buffer *********/
/*********** check for user number ********************/
if (authCheck){
userNo = split((char *) buffer, "\"", &userNoCounter);
if (equals(userNo[3], AUTH_PHONENO) == 0){
freeSplitedString(userNo, userNoCounter);
sendMessage1 (phoneNo, "Unknown number detected: ", userNo[3], 2);
msgReceived = 0;
msgNumber = -1;
msgNumber1 = -1;
continue;
}
freeSplitedString(userNo, userNoCounter);
}
/******************************************************/
/********** Check for message format ******************/
//@1 Spliting message
char *tempA2Lower;
a = split((char*) buffer, checkPattern, (int *)&counter);
tempA2Lower = toLower(a[2]);
free(a[2]);
a[2] = tempA2Lower;
textContent = split (a[2], " ", &textContentCounter);
pinCode = textContent[0];
vmCode = textContent[1];
productCode = textContent[2];
//@1 Complete
//@2 Check for 6 digit pinCode
if (length(pinCode) == 6){
//@3 check for vmMachine code
if (equals(vmCode, "vm001") == 1){
//@4 check for itemcode
char *subSubString;
subSubString = subString(productCode, 0, 1);
if (equals(subSubString, "a")){
char *subSubString2;
//@5 check for productValue
int productValue;
subSubString2 = subString(productCode, 1, 2);
productValue = toInteger(subSubString2);
if (productValue > 6 || productValue < 1){
/**** unavailable product ***********/
LCDPrintLines("Error: ", "unavailable product");
whatIsGoingOn = ERRORA;
/************************************/
} else {
/******** Every thing is correct drop the product *****/
//@6 drop the product and display in LCD
PORTC = (1 << (5 - (productValue - 1)));
LCDPrintLines("Dropping", "Product: ");
LCDPrint(subSubString2);
//@6 (drop the product and display in LCD) complete
//@7 start motor and count for 2 sec
unsigned int fallCounter = 0;
while ((!(bit_is_set(PINA, PA6))) && (!(bit_is_set(PINA, PA7)))) {
/******* find out time take here *******/
_delay_ms(1);
if (fallCounter > 2000){
break;
}
fallCounter++;
/****************************************/
}
//@8 stop the motor and check for time
PORTC = 0x00;
if (fallCounter >= 2000) {
/*********** overFall error **************/
LCDPrintLines("Error: ", "Overfall");
whatIsGoingOn = ERRORO;
/*****************************************/
} else {
/*********** success **************/
LCDPrint("Drop success");
whatIsGoingOn = MESSAGE_SEND_SUCCESSFULLY;
/*****************************************/
}
//@7 () Complete
/******************************************************/
}
free (subSubString2);
//@5 (Product value check) complete
} else {
/****** invalid vmCode *******/
LCDPrintLines("Error: ", "productCode invalid");
whatIsGoingOn = ERRORP;
/*****************************/
}
free (subSubString);
//@4 (check for itemcode) complete
} else {
/****** invalid vmCode *******/
LCDPrintLines("Error: ", "vmCode invalid");
whatIsGoingOn = ERRORV;
/*****************************/
}
//@3 (check for vmMachine code) completed
} else {
/******* invalid pinCode *******/
LCDPrintLines("Error: und.", "pinCode length");
whatIsGoingOn = ERRORPA;
/*******************************/
}
//@2 (check for 6 digit pinCode) complete
freeSplitedString (a, counter);
freeSplitedString (textContent, textContentCounter);
/******************************************************/
/******************************************************/
} else if (okComplete == 2){
/**************** error reading sms *******************/
LCDPrintLines("Err Reading SMS", "5 Retries Error");
whatIsGoingOn = ERRORR;
/******************************************************/
}
//@2 reset EEPROM
//@2 (reset EEPROM) complete
_delay_ms(1000);
msgNumber = -1;
msgNumber1 = -1;
msgReceived = 0;
/***********************************************************************/
ringReceived = 0;
}
}
return 0;
}
