void validateInitializer(const InitializerExpression& expression,ValueType expectedType,const char* context)
{
switch(expression.type)
{
case InitializerExpression::Type::i32_const:
validateType(expectedType,ValueType::i32,context);
break;
case InitializerExpression::Type::i64_const:
validateType(expectedType,ValueType::i64,context);
break;
case InitializerExpression::Type::f32_const:
validateType(expectedType,ValueType::f32,context);
break;
case InitializerExpression::Type::f64_const:
validateType(expectedType,ValueType::f64,context);
break;
case InitializerExpression::Type::get_global:
{
const ValueType globalValueType = validateGlobalIndex(expression.globalIndex,false,true,true,"initializer expression global index");
validateType(expectedType,globalValueType,context);
break;
}
default:
throw ValidationException("invalid initializer expression");
};
}
void
xmlrpc_read_base64(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
size_t * const lengthP,
const unsigned char ** const byteStringValueP) {
validateType(envP, valueP, XMLRPC_TYPE_BASE64);
if (!envP->fault_occurred) {
size_t const size =
XMLRPC_MEMBLOCK_SIZE(char, &valueP->_block);
const char * const contents =
XMLRPC_MEMBLOCK_CONTENTS(char, &valueP->_block);
char * byteStringValue;
byteStringValue = malloc(size);
if (byteStringValue == NULL)
xmlrpc_faultf(envP,
"Unable to allocate %u bytes for byte string.",
(unsigned)size);
else {
memcpy(byteStringValue, contents, size);
*byteStringValueP = (const unsigned char *)byteStringValue;
*lengthP = size;
}
}
void popAndValidateOperand(const ValueType expectedType)
{
if(controlStack.back().isReachable)
{
validateStackAccess(1);
validateType(stack.back(),expectedType,"operand");
stack.pop_back();
}
}
void
xmlrpc_read_bool(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
xmlrpc_bool * const boolValueP) {
validateType(envP, valueP, XMLRPC_TYPE_BOOL);
if (!envP->fault_occurred)
*boolValueP = valueP->_value.b;
}
void
xmlrpc_read_int(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
xmlrpc_int32 * const intValueP) {
validateType(envP, valueP, XMLRPC_TYPE_INT);
if (!envP->fault_occurred)
*intValueP = valueP->_value.i;
}
void AbstractValue::filterValueByType()
{
// We could go further, and ensure that if the futurePossibleStructure contravenes
// the value, then we could clear both of those things. But that's unlikely to help
// in any realistic scenario, so we don't do it. Simpler is better.
if (!!m_type) {
// The type is still non-empty. It may be that the new type renders
// the value empty because it contravenes the constant value we had.
if (m_value && !validateType(m_value))
clear();
return;
}
// The type has been rendered empty. That means that the value must now be invalid,
// as well.
ASSERT(!m_value || !validateType(m_value));
m_value = JSValue();
}
void
xmlrpc_read_double(xmlrpc_env * const envP,
const xmlrpc_value * const valueP,
xmlrpc_double * const doubleValueP) {
validateType(envP, valueP, XMLRPC_TYPE_DOUBLE);
if (!envP->fault_occurred)
*doubleValueP = valueP->_value.d;
}
void popAndValidateOperands(const ValueType* expectedTypes,size_t num)
{
if(controlStack.back().isReachable)
{
validateStackAccess(num);
for(uintp operandIndex = 0; operandIndex < num; ++operandIndex)
{
validateType(stack[stack.size()-num+operandIndex],expectedTypes[operandIndex],"operand");
}
stack.resize(stack.size() - num);
}
}
// Adds an event listener to the list for that event type. Returns false if listener is not added, true if added
bool EventManager::addListener(EventListenerPtr const & listener, EventType const & type)
{
if (!validateType(type))
return false;
EventTypeSet::iterator it = m_eventTypes.find(type);
// Looks to see if the event is a type seen before and adds the event type if not.
if (it == m_eventTypes.end())
{
EventTypeSetRet itEvent = m_eventTypes.insert(type);
if (itEvent.second == false)
return false;
if (itEvent.first == m_eventTypes.end())
return false;
it = itEvent.first;
}
EventListenerMap::iterator itMap = m_listenerMap.find(type.getId());
// Finds the list of listeners for the event type and creates one if it doesn't exist.
if (itMap == m_listenerMap.end())
{
EventListenerMapRet itListMap = m_listenerMap.insert(EventListenerMapEntry(type.getId(), EventListenerList()));
if (itListMap.second == false)
return false;
if (itListMap.first == m_listenerMap.end())
return false;
itMap = itListMap.first;
}
EventListenerList & theList= (*itMap).second;
// Checks to see if the listener is already in the map.
for (EventListenerList::iterator i = theList.begin(); i != theList.end(); i++)
{
if ((*i) == listener)
return false;
}
theList.push_back(listener);
return true;
}
// Adds event to event queue. Returns true if added.
bool EventManager::queueEvent(EventPtr const & event)
{
EventType type = event->getType();
if (!validateType(type))
return false;
EventListenerMap::iterator itMap = m_listenerMap.find(type.getId());
if (itMap == m_listenerMap.end())
return false;
m_eventQueue.push_back(event);
return true;
}
int main(int argc, const char *argv[]) {
// yydebug = 1;
if(argc == 2) {
yyin = fopen(argv[1], "r");
}
yyparse();
if(argc == 2) {
fclose(yyin);
}
fillSymbols(root);
validateType(root);
// if we came this far, the code is correct
fprintf(stderr, "OK\n");
printTree(root, 0);
generatePCode(root);
freeTree(root);
return EXIT_SUCCESS;
}
// Instantly triggers an event. Returns true if event is processed
bool EventManager::triggerEvent(Event const & event)
{
EventType type = event.getType();
if (!validateType(type))
return false;
EventListenerMap::iterator itMap = m_listenerMap.find(type.getId());
if (itMap == m_listenerMap.end())
return false;
EventListenerList theList = (*itMap).second;
bool processed = false;
for (EventListenerList::iterator i = theList.begin(); i != theList.end(); i++)
{
if ((*i)->HandleEvent(event))
processed = true;
}
return processed;
}
