bool ClientAdapter::OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser, CefRefPtr<CefRequest> request, CefString& redirectUrl, CefRefPtr<CefStreamReader>& resourceStream, CefRefPtr<CefResponse> response, int loadFlags)
{
IBeforeResourceLoad^ handler = _browserControl->BeforeResourceLoadHandler;
if(handler != nullptr)
{
CefRequestWrapper^ wrapper = gcnew CefRequestWrapper(request);
RequestResponse^ requestResponse = gcnew RequestResponse(wrapper);
handler->HandleBeforeResourceLoad(_browserControl, requestResponse);
if(requestResponse->Action == ResponseAction::Respond)
{
CefRefPtr<StreamAdapter> adapter = new StreamAdapter(requestResponse->ResponseStream);
resourceStream = CefStreamReader::CreateForHandler(static_cast<CefRefPtr<CefReadHandler>>(adapter));
response->SetMimeType(toNative(requestResponse->MimeType));
return false;
}
else if(requestResponse->Action == ResponseAction::Cancel)
{
return true;
}
else if(requestResponse->Action == ResponseAction::Redirect)
{
redirectUrl = toNative(requestResponse->RedirectUrl);
}
}
return false;
}
v8::Handle<v8::Value> V8AudioNode::connectCallback(const v8::Arguments& args)
{
if (args.Length() < 1)
return throwError("Not enough arguments", V8Proxy::SyntaxError);
AudioNode* destinationNode = toNative(args[0]->ToObject());
if (!destinationNode)
return throwError("Invalid destination node", V8Proxy::SyntaxError);
unsigned output = 0;
unsigned input = 0;
bool ok = false;
if (args.Length() > 1) {
output = toInt32(args[1], ok);
if (!ok)
return throwError("Invalid index parameters", V8Proxy::SyntaxError);
}
if (args.Length() > 2) {
input = toInt32(args[2], ok);
if (!ok)
return throwError("Invalid index parameters", V8Proxy::SyntaxError);
}
AudioNode* audioNode = toNative(args.Holder());
bool success = audioNode->connect(destinationNode, output, input);
if (!success)
return throwError("Invalid index parameter", V8Proxy::SyntaxError);
return v8::Undefined();
}
v8::Handle<v8::Value> V8WebSocket::closeCallback(const v8::Arguments& args)
{
// FIXME: We should implement [Clamp] for IDL binding code generator, and
// remove this custom method.
WebSocket* webSocket = toNative(args.Holder());
int argumentCount = args.Length();
int code = WebSocketChannel::CloseEventCodeNotSpecified;
String reason = "";
if (argumentCount >= 1) {
double x = args[0]->NumberValue();
double maxValue = static_cast<double>(std::numeric_limits<uint16_t>::max());
double minValue = static_cast<double>(std::numeric_limits<uint16_t>::min());
if (isnan(x))
x = 0.0;
else
x = clampTo(x, minValue, maxValue);
code = clampToInteger(x);
if (argumentCount >= 2) {
v8::TryCatch tryCatch;
v8::Handle<v8::String> reasonValue = args[1]->ToString();
if (tryCatch.HasCaught())
return throwError(tryCatch.Exception());
reason = toWebCoreString(reasonValue);
}
}
ExceptionCode ec = 0;
webSocket->close(code, reason, ec);
if (ec)
return throwError(ec);
return v8::Undefined();
}
cv::Mat Egbis::update(cv::Mat matHandle, double dblSigma, double dblK, int intMin, int* intSegments) {
cv::Mat matOutput = cv::Mat();
{
image< rgb >* imageHandle = toNative(&matHandle);
{
int intDummy = 0;
if (intSegments == NULL) {
intSegments = &intDummy;
}
matOutput = segment_image(toNative(&matHandle), (float) (dblSigma), (double) (dblK), intMin, intSegments);
}
delete imageHandle;
}
return matOutput;
}
v8::Handle<v8::Value> V8AudioContext::createBufferCallback(const v8::Arguments& args)
{
if (args.Length() < 2)
return throwError("Not enough arguments", V8Proxy::SyntaxError);
AudioContext* audioContext = toNative(args.Holder());
ASSERT(audioContext);
v8::Handle<v8::Value> arg = args[0];
// AudioBuffer createBuffer(in ArrayBuffer buffer, in boolean mixToMono);
if (V8ArrayBuffer::HasInstance(arg)) {
v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(arg);
ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(object);
ASSERT(arrayBuffer);
if (arrayBuffer) {
bool mixToMono = args[1]->ToBoolean()->Value();
RefPtr<AudioBuffer> audioBuffer = audioContext->createBuffer(arrayBuffer, mixToMono);
if (!audioBuffer.get())
return throwError("Error decoding audio file data", V8Proxy::SyntaxError);
return toV8(audioBuffer.get());
}
return v8::Undefined();
}
// AudioBuffer createBuffer(in unsigned long numberOfChannels, in unsigned long numberOfFrames, in float sampleRate);
if (args.Length() < 3)
return throwError("Not enough arguments", V8Proxy::SyntaxError);
bool ok = false;
int32_t numberOfChannels = toInt32(args[0], ok);
if (!ok || numberOfChannels <= 0 || numberOfChannels > 10)
return throwError("Invalid number of channels", V8Proxy::SyntaxError);
int32_t numberOfFrames = toInt32(args[1], ok);
if (!ok || numberOfFrames <= 0)
return throwError("Invalid number of frames", V8Proxy::SyntaxError);
float sampleRate = toFloat(args[2]);
RefPtr<AudioBuffer> audioBuffer = audioContext->createBuffer(numberOfChannels, numberOfFrames, sampleRate);
if (!audioBuffer.get())
return throwError("Error creating AudioBuffer", V8Proxy::SyntaxError);
return toV8(audioBuffer.get());
}
inline void DOMWrapperMap<NPObject>::makeWeakCallback(v8::Isolate* isolate, v8::Persistent<v8::Object>* wrapper, DOMWrapperMap<NPObject>*)
{
NPObject* npObject = static_cast<NPObject*>(toNative(*wrapper));
ASSERT(npObject);
ASSERT(staticNPObjectMap().get(npObject) == *wrapper);
// Must remove from our map before calling _NPN_ReleaseObject(). _NPN_ReleaseObject can
// call forgetV8ObjectForNPObject, which uses the table as well.
staticNPObjectMap().removeAndDispose(npObject);
if (_NPN_IsAlive(npObject))
_NPN_ReleaseObject(npObject);
}
v8::Handle<v8::Value> V8AudioNode::disconnectCallback(const v8::Arguments& args)
{
unsigned output = 0;
bool ok = false;
if (args.Length() > 0) {
output = toInt32(args[0], ok);
if (!ok)
return throwError("Invalid index parameters", V8Proxy::SyntaxError);
}
AudioNode* audioNode = toNative(args.Holder());
bool success = audioNode->disconnect(output);
if (!success)
return throwError("Invalid index parameter", V8Proxy::SyntaxError);
return v8::Undefined();
}
v8::Handle<v8::Value> V8CustomElementConstructor::callAsFunctionCallback(const v8::Arguments& args)
{
if (!args.IsConstructCall())
return throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
if (ConstructorMode::current() == ConstructorMode::WrapExistingObject)
return args.Holder();
CustomElementConstructor* impl = toNative(args.Holder());
ExceptionCode ec = 0;
RefPtr<Element> element = impl->createElement(ec);
if (ec) {
setDOMException(ec, args.GetIsolate());
return v8Undefined();
}
return toV8(element.get(), args.Holder(), args.GetIsolate());
}
bool SchemeHandlerWrapper::ProcessRequest(CefRefPtr<CefRequest> request, CefRefPtr<CefSchemeHandlerCallback> callback)
{
bool handled = false;
Stream^ stream;
String^ mimeType;
AutoLock lock_scope(this);
IRequest^ requestWrapper = gcnew CefRequestWrapper(request);
if (_handler->ProcessRequest(requestWrapper, mimeType, stream))
{
_mime_type = toNative(mimeType);
_stream = stream;
callback->HeadersAvailable();
handled = true;
}
return handled;
}
ActiveDOMObject* V8DOMFileSystem::toActiveDOMObject(v8::Handle<v8::Object> object)
{
return toNative(object);
}
NativePath::NativePath(char const *cStr, dsize length)
: Path(toNative(String(cStr, length)), DIR_SEPARATOR)
{}
void VirtualMachine::_pop8(uint8_t& arg1)
{
arg1 = mem<uint8_t>(toNative(esp));
esp = fromNative(toNative(esp) + 1);
}
void VirtualMachine::_pop16(uint16_t& arg1)
{
arg1 = mem<uint16_t>(toNative(esp));
esp = fromNative(toNative(esp) + 2);
}
static void
callback_invoke(JNIEnv* env, callback *cb, ffi_cif* cif, void *resp, void **cbargs) {
jobject self;
void *oldresp = resp;
self = (*env)->NewLocalRef(env, cb->object);
// Avoid calling back to a GC'd object
if ((*env)->IsSameObject(env, self, NULL)) {
fprintf(stderr, "JNA: callback object has been garbage collected\n");
if (cif->rtype->type != FFI_TYPE_VOID) {
memset(resp, 0, cif->rtype->size);
}
}
else if (cb->direct) {
unsigned int i;
void **args = alloca((cif->nargs + 3) * sizeof(void *));
args[0] = (void *)&env;
args[1] = &self;
args[2] = &cb->methodID;
memcpy(&args[3], cbargs, cif->nargs * sizeof(void *));
if (cb->flags) {
for (i=0;i < cif->nargs;i++) {
switch(cb->flags[i]) {
case CVT_INTEGER_TYPE:
case CVT_POINTER_TYPE:
case CVT_NATIVE_MAPPED:
*((void **)args[i+3]) = fromNative(env, cb->arg_classes[i], cif->arg_types[i], args[i+3], JNI_FALSE);
break;
case CVT_POINTER:
*((void **)args[i+3]) = newJavaPointer(env, *(void **)args[i+3]);
break;
case CVT_STRING:
*((void **)args[i+3]) = newJavaString(env, *(void **)args[i+3], JNI_FALSE);
break;
case CVT_WSTRING:
*((void **)args[i+3]) = newJavaWString(env, *(void **)args[i+3]);
break;
case CVT_STRUCTURE:
*((void **)args[i+3]) = newJavaStructure(env, *(void **)args[i+3], cb->arg_classes[i], JNI_FALSE);
break;
case CVT_STRUCTURE_BYVAL:
{
void *ptr = args[i+3];
args[i+3] = alloca(sizeof(void *));
*((void **)args[i+3]) = newJavaStructure(env, ptr, cb->arg_classes[i], JNI_TRUE);
}
break;
case CVT_CALLBACK:
*((void **)args[i+3]) = newJavaCallback(env, *(void **)args[i+3], cb->arg_classes[i]);
break;
case CVT_FLOAT:
{
void *ptr = alloca(sizeof(double));
*(double *)ptr = *(float*)args[i+3];
args[i+3] = ptr;
}
break;
}
}
}
if (cb->rflag == CVT_STRUCTURE_BYVAL) {
resp = alloca(sizeof(jobject));
}
else if (cb->cif.rtype->size > cif->rtype->size) {
resp = alloca(cb->cif.rtype->size);
}
ffi_call(&cb->java_cif, FFI_FN(cb->fptr), resp, args);
if ((*env)->ExceptionCheck(env)) {
jthrowable throwable = (*env)->ExceptionOccurred(env);
(*env)->ExceptionClear(env);
if (!handle_exception(env, self, throwable)) {
fprintf(stderr, "JNA: error handling callback exception, continuing\n");
}
if (cif->rtype->type != FFI_TYPE_VOID)
memset(oldresp, 0, cif->rtype->size);
}
else switch(cb->rflag) {
case CVT_INTEGER_TYPE:
if (cb->cif.rtype->size > sizeof(ffi_arg)) {
*(jlong *)oldresp = getIntegerTypeValue(env, *(void **)resp);
}
else {
*(ffi_arg *)oldresp = (ffi_arg)getIntegerTypeValue(env, *(void **)resp);
}
break;
case CVT_POINTER_TYPE:
*(void **)resp = getPointerTypeAddress(env, *(void **)resp);
break;
case CVT_NATIVE_MAPPED:
toNative(env, *(void **)resp, oldresp, cb->cif.rtype->size, JNI_TRUE);
break;
case CVT_POINTER:
*(void **)resp = getNativeAddress(env, *(void **)resp);
break;
case CVT_STRING:
*(void **)resp = getNativeString(env, *(void **)resp, JNI_FALSE);
break;
case CVT_WSTRING:
*(void **)resp = getNativeString(env, *(void **)resp, JNI_TRUE);
break;
case CVT_STRUCTURE:
writeStructure(env, *(void **)resp);
*(void **)resp = getStructureAddress(env, *(void **)resp);
break;
case CVT_STRUCTURE_BYVAL:
writeStructure(env, *(void **)resp);
memcpy(oldresp, getStructureAddress(env, *(void **)resp), cb->cif.rtype->size);
break;
case CVT_CALLBACK:
*(void **)resp = getCallbackAddress(env, *(void **)resp);
break;
default: break;
}
if (cb->flags) {
for (i=0;i < cif->nargs;i++) {
if (cb->flags[i] == CVT_STRUCTURE) {
writeStructure(env, *(void **)args[i+3]);
}
}
}
}
else {
jobject result;
jobjectArray array =
(*env)->NewObjectArray(env, cif->nargs, classObject, NULL);
unsigned int i;
for (i=0;i < cif->nargs;i++) {
jobject arg = new_object(env, cb->arg_jtypes[i], cbargs[i], JNI_FALSE);
(*env)->SetObjectArrayElement(env, array, i, arg);
}
result = (*env)->CallObjectMethod(env, self, cb->methodID, array);
if ((*env)->ExceptionCheck(env)) {
jthrowable throwable = (*env)->ExceptionOccurred(env);
(*env)->ExceptionClear(env);
if (!handle_exception(env, self, throwable)) {
fprintf(stderr, "JNA: error handling callback exception, continuing\n");
}
if (cif->rtype->type != FFI_TYPE_VOID)
memset(resp, 0, cif->rtype->size);
}
else {
extract_value(env, result, resp, cif->rtype->size, JNI_TRUE);
}
}
}
void VirtualMachine::_pop32(uint32_t& arg1)
{
arg1 = mem<uint32_t>(toNative(esp));
esp = fromNative(toNative(esp) + 4);
}
EventTarget* V8TestInterfaceEventTarget::toEventTarget(v8::Handle<v8::Object> object)
{
return toNative(object);
}
static void
invoke_callback(JNIEnv* env, callback *cb, ffi_cif* cif, void *resp, void **cbargs) {
jobject self;
void *oldresp = resp;
self = (*env)->NewLocalRef(env, cb->object);
// Avoid calling back to a GC'd object
if ((*env)->IsSameObject(env, self, NULL)) {
fprintf(stderr, "JNA: callback object has been garbage collected\n");
if (cif->rtype->type != FFI_TYPE_VOID) {
memset(resp, 0, cif->rtype->size);
}
}
else if (cb->direct) {
unsigned int i;
void **args = alloca((cif->nargs + 3) * sizeof(void *));
args[0] = (void *)&env;
args[1] = &self;
args[2] = &cb->methodID;
memcpy(&args[3], cbargs, cif->nargs * sizeof(void *));
// Note that there is no support for CVT_TYPE_MAPPER here
if (cb->conversion_flags) {
for (i=0;i < cif->nargs;i++) {
switch(cb->conversion_flags[i]) {
case CVT_INTEGER_TYPE:
case CVT_POINTER_TYPE:
case CVT_NATIVE_MAPPED:
case CVT_NATIVE_MAPPED_STRING:
case CVT_NATIVE_MAPPED_WSTRING:
// Make sure we have space enough for the new argument
args[i+3] = alloca(sizeof(void *));
*((void **)args[i+3]) = fromNativeCallbackParam(env, cb->arg_classes[i], cif->arg_types[i], cbargs[i], JNI_FALSE, cb->encoding);
break;
case CVT_POINTER:
*((void **)args[i+3]) = newJavaPointer(env, *(void **)cbargs[i]);
break;
case CVT_STRING:
*((void **)args[i+3]) = newJavaString(env, *(void **)cbargs[i], cb->encoding);
break;
case CVT_WSTRING:
*((void **)args[i+3]) = newJavaWString(env, *(void **)cbargs[i]);
break;
case CVT_STRUCTURE:
*((void **)args[i+3]) = newJavaStructure(env, *(void **)cbargs[i], cb->arg_classes[i]);
break;
case CVT_STRUCTURE_BYVAL:
args[i+3] = alloca(sizeof(void *));
*((void **)args[i+3]) = newJavaStructure(env, cbargs[i], cb->arg_classes[i]);
break;
case CVT_CALLBACK:
*((void **)args[i+3]) = newJavaCallback(env, *(void **)cbargs[i], cb->arg_classes[i]);
break;
case CVT_FLOAT:
args[i+3] = alloca(sizeof(double));
*((double *)args[i+3]) = *(float*)cbargs[i];
break;
case CVT_DEFAULT:
break;
default:
fprintf(stderr, "JNA: Unhandled arg conversion type %d\n", cb->conversion_flags[i]);
break;
}
}
}
if (cb->rflag == CVT_STRUCTURE_BYVAL) {
resp = alloca(sizeof(jobject));
}
else if (cb->cif.rtype->size > cif->rtype->size) {
resp = alloca(cb->cif.rtype->size);
}
#define FPTR(ENV,OFFSET) (*(void **)((char *)(*(ENV)) + OFFSET))
#define JNI_FN(X) ((void (*)(void))(X))
ffi_call(&cb->java_cif, JNI_FN(FPTR(env, cb->fptr_offset)), resp, args);
if ((*env)->ExceptionCheck(env)) {
jthrowable throwable = (*env)->ExceptionOccurred(env);
(*env)->ExceptionClear(env);
if (!handle_exception(env, self, throwable)) {
fprintf(stderr, "JNA: error handling callback exception, continuing\n");
}
if (cif->rtype->type != FFI_TYPE_VOID) {
memset(oldresp, 0, cif->rtype->size);
}
}
else switch(cb->rflag) {
case CVT_INTEGER_TYPE:
if (cb->cif.rtype->size > sizeof(ffi_arg)) {
*(jlong *)oldresp = getIntegerTypeValue(env, *(void **)resp);
}
else {
*(ffi_arg *)oldresp = (ffi_arg)getIntegerTypeValue(env, *(void **)resp);
}
break;
case CVT_POINTER_TYPE:
*(void **)resp = getPointerTypeAddress(env, *(void **)resp);
break;
case CVT_NATIVE_MAPPED:
toNative(env, *(void **)resp, oldresp, cb->cif.rtype->size, JNI_TRUE, cb->encoding);
break;
case CVT_NATIVE_MAPPED_STRING:
case CVT_NATIVE_MAPPED_WSTRING:
// TODO: getNativeString rather than allocated memory
fprintf(stderr, "JNA: Likely memory leak here\n");
toNative(env, *(void **)resp, oldresp, cb->cif.rtype->size, JNI_TRUE, cb->encoding);
break;
case CVT_POINTER:
*(void **)resp = getNativeAddress(env, *(void **)resp);
break;
case CVT_STRING:
*(void **)resp = getNativeString(env, *(void **)resp, JNI_FALSE);
break;
case CVT_WSTRING:
*(void **)resp = getNativeString(env, *(void **)resp, JNI_TRUE);
break;
case CVT_STRUCTURE:
writeStructure(env, *(void **)resp);
*(void **)resp = getStructureAddress(env, *(void **)resp);
break;
case CVT_STRUCTURE_BYVAL:
writeStructure(env, *(void **)resp);
memcpy(oldresp, getStructureAddress(env, *(void **)resp), cb->cif.rtype->size);
break;
case CVT_CALLBACK:
*(void **)resp = getCallbackAddress(env, *(void **)resp);
break;
case CVT_DEFAULT:
break;
default:
fprintf(stderr, "JNA: Unhandled result conversion: %d\n", cb->rflag);
break;
}
if (cb->conversion_flags) {
for (i=0;i < cif->nargs;i++) {
if (cb->conversion_flags[i] == CVT_STRUCTURE) {
writeStructure(env, *(void **)cbargs[i]);
}
}
}
}
else {
jobject result;
jobjectArray params =
(*env)->NewObjectArray(env, cif->nargs, classObject, NULL);
unsigned int i;
for (i=0;i < cif->nargs;i++) {
jobject arg = new_object(env, cb->arg_jtypes[i], cbargs[i], JNI_FALSE, cb->encoding);
(*env)->SetObjectArrayElement(env, params, i, arg);
}
result = (*env)->CallObjectMethod(env, self, cb->methodID, params);
if ((*env)->ExceptionCheck(env)) {
jthrowable throwable = (*env)->ExceptionOccurred(env);
(*env)->ExceptionClear(env);
if (!handle_exception(env, self, throwable)) {
fprintf(stderr, "JNA: error while handling callback exception, continuing\n");
}
if (cif->rtype->type != FFI_TYPE_VOID)
memset(resp, 0, cif->rtype->size);
}
else {
extract_value(env, result, resp, cif->rtype->size, JNI_TRUE, cb->encoding);
}
}
}
NativePath::NativePath(QString const &qstr) : Path(toNative(qstr), DIR_SEPARATOR)
{}
NativePath &NativePath::operator = (QString const &str)
{
set(toNative(str), DIR_SEPARATOR);
return *this;
}
ActiveDOMObject* V8TestNamedConstructor::toActiveDOMObject(v8::Handle<v8::Object> wrapper)
{
return toNative(wrapper);
}
EventTarget* V8TestNode::toEventTarget(v8::Handle<v8::Object> object)
{
return toNative(object);
}
std::vector< toppers::xml::container::object* > cfg1_out::xml_parser_init( std::string input_file )
{
SAX2XMLReader::ValSchemes valScheme = SAX2XMLReader::Val_Auto;
bool doNamespaces = true;
bool doSchema = true;
bool schemaFullChecking = false;
bool identityConstraintChecking = true;
bool namespacePrefixes = true;
bool recognizeNEL = false;
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
std::vector<toppers::xml::container::object*> object_array;
fatal( _("Error during initialization! Message:\n%" ), toNative(toCatch.getMessage()));
return object_array;
}
//
// Create a SAX parser object. Then, according to what we were told on
// the command line, set it to validate or not.
//
SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces);
parser->setFeature(XMLUni::fgXercesSchema, doSchema);
parser->setFeature(XMLUni::fgXercesHandleMultipleImports, true);
parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking);
parser->setFeature(XMLUni::fgXercesIdentityConstraintChecking, identityConstraintChecking);
parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, namespacePrefixes);
if (valScheme == SAX2XMLReader::Val_Auto)
{
parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
parser->setFeature(XMLUni::fgXercesDynamic, true);
}
if (valScheme == SAX2XMLReader::Val_Never)
{
parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
}
if (valScheme == SAX2XMLReader::Val_Always)
{
parser->setFeature(XMLUni::fgSAX2CoreValidation, true);
parser->setFeature(XMLUni::fgXercesDynamic, false);
}
/* External Schema file */
// XMLファイルのチェック
namespace fs = boost::filesystem;
if( !fs::exists( input_file ) )
{
fatal( _("'%1%` is not exist."), input_file );
}
/* 設定ファイルがある場合はパラメータ名のチェックを行う */
std::string paraname( get_global_string( "ini-file" ) );
std::string strAUTOSARVersion;
std::string strSchema;
std::string strSchemaLocation;
std::string strContainerPath;
std::string strModuleName;
//std::cout << "AUTOSAR ini-file (ini file name):[" << paraname << "]" << std::endl;
if( !paraname.empty() )
{
strAUTOSARVersion = get_global_string( "XML_AUTOSARVersion" );
if( strAUTOSARVersion.empty() )
{
strAUTOSARVersion = "4";
warning( _( " \"AUTOSARVersion\" parameter is not found in AUTOSAR ini-file. Use default value." ) );
}
strSchema = get_global_string( "XML_Schema" );
if( strSchema.empty() )
{
strSchema = "AUTOSAR_4-0-3_STRICT.xsd";
warning( _( " \"Schema\" parameter is not found in AUTOSAR ini-file. Use default value." ) );
}
strSchemaLocation = get_global_string( "XML_SchemaLocation" );
if( strSchemaLocation.empty() )
{
strSchemaLocation = "http://autosar.org/schema/r4.0";
warning( _( " \"SchemaLocation\" parameter is not found in AUTOSAR ini-file. Use default value." ) );
}
strContainerPath = get_global_string( "XML_ContainerPath" );
if( strContainerPath.empty() )
{
strContainerPath = "/AUTOSAR/EcucDefs";
warning( _( " \"ContainerPath\" parameter is not found in AUTOSAR ini-file. Use default value." ) );
}
}
toppers::global( "XML_AUTOSARVersion" ) = strAUTOSARVersion;
toppers::global( "XML_Schema" ) = strSchema;
toppers::global( "XML_SchemaLocation" ) = strSchemaLocation;
toppers::global( "XML_ContainerPath" ) = strContainerPath;
// XMLファイルの中にxsi:schemaLocation属性があればその要素を取得
std::string sstr( "xsi:schemaLocation" );
std::string buf;
toppers::read( input_file, buf );
std::list<std::string> results;
string::size_type index( buf.find( sstr ) );
if( index != string::npos )
{
string::size_type index2( buf.substr( index ).find( "\"" ) );
string::size_type index3( buf.substr( index+index2+1 ).find( "\"" ) );
sstr = buf.substr( index+index2+1, index3 );
split( results, sstr, boost::is_space() );
}
// スキーマファイルのチェック
std::ostringstream ostream;
if( results.size() == 2 && fs::exists( results.back() ) )
{
ostream << sstr;
}
else
{
ostream << get_global_string( "XML_SchemaLocation" ) << " " << fs::absolute( get_global_string( "cfg-directory" ).c_str() ).string()
<< "/" << get_global_string( "XML_Schema" );
}
XMLCh* str (XMLString::transcode (ostream.str().c_str()));
parser->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation, str);
//
// Create our SAX handler object and install it on the parser, as the
// document and error handler.
//
SAX2Handlers handler;
parser->setContentHandler(&handler);
parser->setErrorHandler(&handler);
//reset error count first
handler.resetErrors();
handler.filename = input_file;
try
{
parser->parse(input_file.c_str());
}
catch (const OutOfMemoryException&)
{
warning("OutOfMemoryException");
}
catch (const XMLException& e)
{
warning( _("\nError during parsing: '%'\nException message is: \n%\n"), input_file, toNative(e.getMessage()));
}
catch (...)
{
warning( _("\nUnexpected exception during parsing: '%'\n"), input_file);
}
delete parser;
XMLPlatformUtils::Terminate();
return handler.object_array;
}
NativePath::NativePath(char const *nullTerminatedCStr)
: Path(toNative(nullTerminatedCStr), DIR_SEPARATOR)
{}
namespace pylazperf
{
// Stolen from PDAL
template<typename E>
constexpr typename std::underlying_type<E>::type toNative(E e)
{
return static_cast<typename std::underlying_type<E>::type>(e);
}
enum class BaseType
{
None = 0x000,
Signed = 0x100,
Unsigned = 0x200,
Floating = 0x400
};
enum Type
{
None = 0,
Unsigned8 = toNative(BaseType::Unsigned) | 1,
Signed8 = toNative(BaseType::Signed) | 1,
Unsigned16 = toNative(BaseType::Unsigned) | 2,
Signed16 = toNative(BaseType::Signed) | 2,
Unsigned32 = toNative(BaseType::Unsigned) | 4,
Signed32 = toNative(BaseType::Signed) | 4,
Unsigned64 = toNative(BaseType::Unsigned) | 8,
Signed64 = toNative(BaseType::Signed) | 8,
Float = toNative(BaseType::Floating) | 4,
Double = toNative(BaseType::Floating) | 8
};
inline std::string toName(BaseType b)
{
switch (b)
{
case BaseType::Signed:
return "signed";
case BaseType::Unsigned:
return "unsigned";
case BaseType::Floating:
return "floating";
default:
return "";
}
}
inline BaseType base(Type t)
{
return BaseType(toNative(t) & 0xFF00);
}
inline size_t size(Type t)
{
return t & 0xFF;
}
inline std::string interpretationName(Type dimtype)
{
switch (dimtype)
{
case Type::None:
return "unknown";
case Type::Signed8:
return "int8_t";
case Type::Signed16:
return "int16_t";
case Type::Signed32:
return "int32_t";
case Type::Signed64:
return "int64_t";
case Type::Unsigned8:
return "uint8_t";
case Type::Unsigned16:
return "uint16_t";
case Type::Unsigned32:
return "uint32_t";
case Type::Unsigned64:
return "uint64_t";
case Type::Float:
return "float";
case Type::Double:
return "double";
}
return "unknown";
}
/// Get the type corresponding to a type name.
/// \param s Name of type.
/// \return Corresponding type enumeration value.
inline Type type(std::string s)
{
if (s == "int8_t" || s == "int8")
return Type::Signed8;
if (s == "int16_t" || s == "int16")
return Type::Signed16;
if (s == "int32_t" || s == "int32")
return Type::Signed32;
if (s == "int64_t" || s == "int64")
return Type::Signed64;
if (s == "uint8_t" || s == "uint8")
return Type::Unsigned8;
if (s == "uint16_t" || s == "uint16")
return Type::Unsigned16;
if (s == "uint32_t" || s == "uint32")
return Type::Unsigned32;
if (s == "uint64_t" || s == "uint64")
return Type::Unsigned64;
if (s == "float")
return Type::Float;
if (s == "double")
return Type::Double;
return Type::None;
}
}
ActiveDOMObject* V8TestNamedConstructor::toActiveDOMObject(v8::Handle<v8::Object> object)
{
return toNative(object);
}
inline BaseType base(Type t)
{
return BaseType(toNative(t) & 0xFF00);
}
NativePath::NativePath(String const &str) : Path(toNative(str), DIR_SEPARATOR)
{}
ActiveDOMObject* V8TestInterface::toActiveDOMObject(v8::Handle<v8::Object> object)
{
return toNative(object);
}
