TEST(CountIsEqual, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object.count(), 2);
}
/**
* Walks the chain of objects accessible from the specified CallFrame.
*/
void GarbageCollector::walk_call_frame(CallFrame* top_call_frame,
AddressDisplacement* offset)
{
CallFrame* call_frame = top_call_frame;
while(call_frame) {
call_frame = displace(call_frame, offset);
// Skip synthetic, non CompiledCode frames
if(!call_frame->compiled_code) {
call_frame = call_frame->previous;
continue;
}
if(call_frame->custom_constant_scope_p() &&
call_frame->constant_scope_ &&
call_frame->constant_scope_->reference_p()) {
call_frame->constant_scope_ =
(ConstantScope*)mark_object(call_frame->constant_scope_);
}
if(call_frame->compiled_code && call_frame->compiled_code->reference_p()) {
call_frame->compiled_code = (CompiledCode*)mark_object(call_frame->compiled_code);
}
if(call_frame->compiled_code && call_frame->stk) {
native_int stack_size = call_frame->compiled_code->stack_size()->to_native();
for(native_int i = 0; i < stack_size; i++) {
Object* obj = call_frame->stk[i];
if(obj && obj->reference_p()) {
call_frame->stk[i] = mark_object(obj);
}
}
}
if(call_frame->multiple_scopes_p() && call_frame->top_scope_) {
call_frame->top_scope_ = (VariableScope*)mark_object(call_frame->top_scope_);
}
if(BlockEnvironment* env = call_frame->block_env()) {
call_frame->set_block_env((BlockEnvironment*)mark_object(env));
}
Arguments* args = displace(call_frame->arguments, offset);
if(!call_frame->inline_method_p() && args) {
args->set_recv(mark_object(args->recv()));
args->set_block(mark_object(args->block()));
if(Tuple* tup = args->argument_container()) {
args->update_argument_container((Tuple*)mark_object(tup));
} else {
Object** ary = displace(args->arguments(), offset);
for(uint32_t i = 0; i < args->total(); i++) {
ary[i] = mark_object(ary[i]);
}
}
}
#ifdef ENABLE_LLVM
if(jit::RuntimeDataHolder* jd = call_frame->jit_data()) {
jd->set_mark();
ObjectMark mark(this);
jd->mark_all(0, mark);
}
if(jit::RuntimeData* rd = call_frame->runtime_data()) {
rd->method_ = (CompiledCode*)mark_object(rd->method());
rd->name_ = (Symbol*)mark_object(rd->name());
rd->module_ = (Module*)mark_object(rd->module());
}
#endif
saw_variable_scope(call_frame, displace(call_frame->scope, offset));
call_frame = call_frame->previous;
}
}
Handle<Value> WKTWriter::New(const Arguments& args) {
HandleScope scope;
WKTWriter* writer = new WKTWriter();
writer->Wrap(args.This());
return args.This();
}
Arguments ArgumentParser::Parse(const std::string& line)
{
Arguments args;
std::string::size_type pos1 = 0;
for (const auto& type : types)
{
if (pos1 == line.length() || pos1 == std::string::npos)
{
throw cmd::SyntaxError();
}
while (line[pos1] == ' ')
{
if (++pos1 == line.length())
{
throw cmd::SyntaxError();
}
}
switch (type.second)
{
case Type::Grouped :
{
if (line[pos1] == '"') // multiple arguments grouped
{
auto pos2 = line.find('"', pos1 + 1);
if (pos2 == std::string::npos)
{
throw cmd::SyntaxError();
}
args.Push(type.first, line.substr(pos1 + 1, pos2 - pos1 - 1));
pos1 = pos2 + 1;
break;
}
// fall through for single ungrouped argument
}
case Type::Single :
{
auto pos2 = line.find(' ', pos1);
if (pos2 == std::string::npos)
{
args.Push(type.first, line.substr(pos1));
pos1 = std::string::npos;
}
else
{
args.Push(type.first, line.substr(pos1, pos2 - pos1));
pos1 = ++pos2;
}
break;
}
case Type::Multiple :
{
auto pos2 = line.length() - 1;
while (line[pos2] == ' ') --pos2;
args.Push(type.first, line.substr(pos1, pos2 - pos1 + 1));
pos1 = std::string::npos;
break;
}
}
}
if (pos1 < line.length() && pos1 != std::string::npos)
{
throw cmd::SyntaxError();
}
return args;
}
Handle<Value> ZipFile::readFileSync(const Arguments& args)
{
HandleScope scope;
if (args.Length() != 1 || !args[0]->IsString())
return ThrowException(Exception::TypeError(
String::New("first argument must be a file name inside the zip")));
std::string name = TOSTR(args[0]);
// TODO - enforce valid index
ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());
if (zf->Busy())
return ThrowException(Exception::Error(String::New("Zipfile already in use..")));
struct zip_file *zf_ptr;
int idx = -1;
std::vector<std::string>::iterator it = std::find(zf->names.begin(), zf->names.end(), name);
if (it!=zf->names.end()) {
idx = distance(zf->names.begin(), it);
}
if (idx == -1) {
std::stringstream s;
s << "No file found by the name of: '" << name << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
if ((zf_ptr=zip_fopen_index(zf->archive, idx, 0)) == NULL) {
zip_fclose(zf_ptr);
std::stringstream s;
s << "cannot open file #" << idx << " in " << name << ": archive error: " << zip_strerror(zf->archive) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
struct zip_stat st;
zip_stat_index(zf->archive, idx, 0, &st);
std::vector<unsigned char> data;
data.clear();
data.resize( st.size );
int result = 0;
result = (int)zip_fread( zf_ptr, reinterpret_cast<void*> (&data[0]), data.size() );
if (result < 0) {
zip_fclose(zf_ptr);
std::stringstream s;
s << "error reading file #" << idx << " in " << name << ": archive error: " << zip_file_strerror(zf_ptr) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
#if NODE_VERSION_AT_LEAST(0,3,0)
node::Buffer *retbuf = Buffer::New((char *)&data[0],data.size());
#else
node::Buffer *retbuf = Buffer::New(data.size());
std::memcpy(retbuf->data(), (char *)&data[0], data.size());
#endif
zip_fclose(zf_ptr);
return scope.Close(retbuf->handle_);
}
Handle<Value> ExampleProxy::printMessage(const Arguments& args)
{
LOGD(TAG, "printMessage()");
HandleScope scope;
JNIEnv *env = titanium::JNIScope::getEnv();
if (!env) {
return titanium::JSException::GetJNIEnvironmentError();
}
static jmethodID methodID = NULL;
if (!methodID) {
methodID = env->GetMethodID(ExampleProxy::javaClass, "printMessage", "(Ljava/lang/String;)V");
if (!methodID) {
const char *error = "Couldn't find proxy method 'printMessage' with signature '(Ljava/lang/String;)V'";
LOGE(TAG, error);
return titanium::JSException::Error(error);
}
}
titanium::Proxy* proxy = titanium::Proxy::unwrap(args.Holder());
if (args.Length() < 1) {
char errorStringBuffer[100];
sprintf(errorStringBuffer, "printMessage: Invalid number of arguments. Expected 1 but got %d", args.Length());
return ThrowException(Exception::Error(String::New(errorStringBuffer)));
}
jvalue jArguments[1];
if (!args[0]->IsNull()) {
Local<Value> arg_0 = args[0];
jArguments[0].l =
titanium::TypeConverter::jsValueToJavaString(env, arg_0);
} else {
jArguments[0].l = NULL;
}
jobject javaProxy = proxy->getJavaObject();
env->CallVoidMethodA(javaProxy, methodID, jArguments);
if (!JavaObject::useGlobalRefs) {
env->DeleteLocalRef(javaProxy);
}
env->DeleteLocalRef(jArguments[0].l);
if (env->ExceptionCheck()) {
titanium::JSException::fromJavaException();
env->ExceptionClear();
}
return v8::Undefined();
}
Handle<Value> CreateExternalArray(const Arguments& args,
ExternalArrayType type,
size_t element_size) {
TryCatch try_catch;
ASSERT_PIN(element_size == 1 || element_size == 2 ||
element_size == 4 || element_size == 8, "CreateExternalArray");
// Currently, only the following constructors are supported:
// TypedArray(unsigned long length)
// TypedArray(ArrayBuffer buffer,
// optional unsigned long byteOffset,
// optional unsigned long length)
Handle<Object> buffer;
int32_t length;
int32_t byteLength;
int32_t byteOffset;
int32_t bufferLength;
if (args.Length() == 0) {
return ThrowException(
String::New("Array constructor must have at least one parameter."));
}
if (args[0]->IsObject() &&
(!args[0]->ToObject()->GetHiddenValue(String::New(kArrayBufferMarkerPropName)).IsEmpty()) ||
(IS_BINARY(args[0]))) {
if (!args[0]->ToObject()->GetHiddenValue(String::New(kArrayBufferMarkerPropName)).IsEmpty()) {
buffer = args[0]->ToObject();
bufferLength = convertToUint(buffer->Get(String::New("byteLength")), &try_catch);
if (try_catch.HasCaught())
return try_catch.Exception();
} else {
buffer = CreateExternalArrayBuffer(args[0])->ToObject();
bufferLength = convertToUint(buffer->Get(String::New("byteLength")), &try_catch);
if (try_catch.HasCaught())
return try_catch.Exception();
}
if (args.Length() < 2 || args[1]->IsUndefined()) {
byteOffset = 0;
} else {
byteOffset = convertToUint(args[1], &try_catch);
if (try_catch.HasCaught()) return try_catch.Exception();
if (byteOffset > bufferLength) {
return ThrowException(String::New("byteOffset out of bounds"));
}
if (byteOffset % element_size != 0) {
return ThrowException(
String::New("byteOffset must be multiple of element_size"));
}
}
if (args.Length() < 3 || args[2]->IsUndefined()) {
byteLength = bufferLength - byteOffset;
length = byteLength / element_size;
if (byteLength % element_size != 0) {
return ThrowException(
String::New("buffer size must be multiple of element_size"));
}
} else {
length = convertToUint(args[2], &try_catch);
if (try_catch.HasCaught())
return try_catch.Exception();
byteLength = length * element_size;
if (byteOffset + byteLength > bufferLength) {
return ThrowException(String::New("length out of bounds"));
}
}
} else {
length = convertToUint(args[0], &try_catch);
byteLength = length * element_size;
byteOffset = 0;
Handle<Value> result = CreateExternalArrayBuffer(byteLength);
if (!result->IsObject())
return result;
buffer = result->ToObject();
}
void* data = buffer->GetIndexedPropertiesExternalArrayData();
ASSERT_PIN(data != NULL, "CreateExternalArray data != NULL");
Handle<Object> array = Object::New();
array->SetIndexedPropertiesToExternalArrayData(
static_cast<uint8_t*>(data) + byteOffset, type, length);
array->Set(String::New("byteLength"), Int32::New(byteLength), ReadOnly);
array->Set(String::New("byteOffset"), Int32::New(byteOffset), ReadOnly);
array->Set(String::New("length"), Int32::New(length), ReadOnly);
array->Set(String::New("BYTES_PER_ELEMENT"), Int32::New(element_size));
array->Set(String::New("buffer"), buffer, ReadOnly);
return array;
}
ClangParser::ClangParser(Arguments& args)
// VC2005: If shouldClose is set to true, this forces an assert in the CRT on program
// shutdown as stdout hasn't been opened by the app in the first place.
: m_OutputStream(1, false)
{
m_CompilerInvocation.reset(new clang::CompilerInvocation);
// we add a customized macro here to distinguish a clreflect parsing process from a compling using clang
clang::PreprocessorOptions& preprocessor_options = m_CompilerInvocation->getPreprocessorOpts();
preprocessor_options.addMacroDef("__clcpp_parse__");
// Add define/undefine macros to the pre-processor
for (int i = 0; ; i++)
{
std::string macro = args.GetProperty("-D", i);
if (macro == "")
break;
preprocessor_options.addMacroDef(macro.c_str());
}
for (int i = 0; ; i++)
{
std::string macro = args.GetProperty("-U", i);
if (macro == "")
break;
preprocessor_options.addMacroUndef(macro.c_str());
}
// Setup the language parsing options for C++
clang::LangOptions& lang_options = *m_CompilerInvocation->getLangOpts();
m_CompilerInvocation->setLangDefaults(lang_options, clang::IK_CXX, clang::LangStandard::lang_cxx03);
lang_options.CPlusPlus = 1;
lang_options.Bool = 1;
lang_options.RTTI = 0;
#if defined(CLCPP_USING_MSVC)
lang_options.MicrosoftExt = 1;
lang_options.MicrosoftMode = 1;
lang_options.MSBitfields = 1;
//
// This is MSVC specific to get STL compiling with clang. MSVC doesn't do semantic analysis
// of templates until instantiation, whereas clang will try to resolve non type-based function
// calls. In MSVC STL land, this causes hundreds of errors referencing '_invalid_parameter_noinfo'.
//
// The problem in a nutshell:
//
// template <typename TYPE> void A()
// {
// // Causes an error in clang because B() is not defined yet, MSVC is fine
// B();
// }
// void B() { }
//
lang_options.DelayedTemplateParsing = 1;
#endif // CLCPP_USING_MSVC
// Gather C++ header searches from the command-line
clang::HeaderSearchOptions& header_search_options = m_CompilerInvocation->getHeaderSearchOpts();
for (int i = 0; ; i++)
{
std::string include = args.GetProperty("-i", i);
if (include == "")
break;
header_search_options.AddPath(include.c_str(), clang::frontend::Angled, false, false, false);
}
for (int i = 0; ; i++)
{
std::string include = args.GetProperty("-isystem", i);
if (include == "")
break;
header_search_options.AddPath(include.c_str(), clang::frontend::System, false, false, false);
}
// Setup diagnostics output; MSVC line-clicking and suppress warnings from system headers
#if defined(CLCPP_USING_MSVC)
m_DiagnosticOptions.Format = m_DiagnosticOptions.Msvc;
#else
m_DiagnosticOptions.Format = m_DiagnosticOptions.Clang;
#endif // CLCPP_USING_MSVC
clang::TextDiagnosticPrinter *client = new clang::TextDiagnosticPrinter(m_OutputStream, m_DiagnosticOptions);
m_CompilerInstance.createDiagnostics(0, NULL, client);
m_CompilerInstance.getDiagnostics().setSuppressSystemWarnings(true);
// Setup target options - ensure record layout calculations use the MSVC C++ ABI
clang::TargetOptions& target_options = m_CompilerInvocation->getTargetOpts();
target_options.Triple = llvm::sys::getDefaultTargetTriple();
#if defined(CLCPP_USING_MSVC)
target_options.CXXABI = "microsoft";
#else
target_options.CXXABI = "itanium";
#endif // CLCPP_USING_MSVC
m_TargetInfo.reset(clang::TargetInfo::CreateTargetInfo(m_CompilerInstance.getDiagnostics(), target_options));
m_CompilerInstance.setTarget(m_TargetInfo.take());
// Set the invokation on the instance
m_CompilerInstance.createFileManager();
m_CompilerInstance.createSourceManager(m_CompilerInstance.getFileManager());
m_CompilerInstance.setInvocation(m_CompilerInvocation.take());
}
Handle<Value> Database::Query(const Arguments& args) {
HandleScope scope;
REQ_STR_ARG(0, sql);
Local<Function> cb;
int paramCount = 0;
Parameter* params;
Database* dbo = ObjectWrap::Unwrap<Database>(args.This());
struct query_request *prep_req = (struct query_request *)
calloc(1, sizeof(struct query_request));
if (!prep_req) {
V8::LowMemoryNotification();
return ThrowException(Exception::Error(String::New("Could not allocate enough memory")));
}
// populate prep_req->params if parameters were supplied
//
if (args.Length() > 2)
{
if ( !args[1]->IsArray() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 1 must be an Array"))
);
}
else if ( !args[2]->IsFunction() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 2 must be a Function"))
);
}
Local<Array> values = Local<Array>::Cast(args[1]);
cb = Local<Function>::Cast(args[2]);
prep_req->paramCount = paramCount = values->Length();
prep_req->params = params = new Parameter[paramCount];
for (int i = 0; i < paramCount; i++)
{
Local<Value> value = values->Get(i);
params[i].size = 0;
params[i].length = NULL;
params[i].buffer_length = 0;
if (value->IsString())
{
String::Utf8Value string(value);
params[i].c_type = SQL_C_CHAR;
params[i].type = SQL_VARCHAR;
params[i].length = SQL_NTS;
params[i].buffer = malloc(string.length() + 1);
params[i].buffer_length = string.length() + 1;
params[i].size = string.length() + 1;
strcpy((char*)params[i].buffer, *string);
}
else if (value->IsNull())
{
params[i].c_type = SQL_C_DEFAULT;
params[i].type = SQL_NULL_DATA;
params[i].length = SQL_NULL_DATA;
}
else if (value->IsInt32())
{
int64_t *number = new int64_t(value->IntegerValue());
params[i].c_type = SQL_C_LONG;
params[i].type = SQL_INTEGER;
params[i].buffer = number;
}
else if (value->IsNumber())
{
double *number = new double(value->NumberValue());
params[i].c_type = SQL_C_DOUBLE;
params[i].type = SQL_DECIMAL;
params[i].buffer = number;
}
else if (value->IsBoolean())
{
bool *boolean = new bool(value->BooleanValue());
params[i].c_type = SQL_C_BIT;
params[i].type = SQL_BIT;
params[i].buffer = boolean;
}
}
}
else
{
if ( !args[1]->IsFunction() )
{
return ThrowException(Exception::TypeError(
String::New("Argument 1 must be a Function"))
);
}
cb = Local<Function>::Cast(args[1]);
prep_req->paramCount = 0;
}
prep_req->sql = (char *) malloc(sql.length() +1);
prep_req->catalog = NULL;
prep_req->schema = NULL;
prep_req->table = NULL;
prep_req->type = NULL;
prep_req->column = NULL;
prep_req->cb = Persistent<Function>::New(cb);
strcpy(prep_req->sql, *sql);
prep_req->dbo = dbo;
eio_custom(EIO_Query, EIO_PRI_DEFAULT, EIO_AfterQuery, prep_req);
ev_ref(EV_DEFAULT_UC);
dbo->Ref();
scope.Close(Undefined());
return Undefined();
}
static bool call(STATE, CallFrame* call_frame,
MachineCode* mcode, StackVariables* scope,
Arguments& args, int flags)
{
const bool has_splat = (mcode->splat_position >= 0);
native_int total_args = args.total();
// expecting 0, got 0.
if(mcode->total_args == 0 && total_args == 0) {
if(has_splat) {
scope->set_local(mcode->splat_position, Array::create(state, 0));
}
return true;
}
// Only do destructuring in non-lambda mode
if((flags & CallFrame::cIsLambda) == 0) {
/* If only one argument was yielded and:
*
* 1. the block takes two or more arguments
* 2. OR takes one argument and a splat
* 3. OR has the form { |a, | }
* 4. OR has the form { |(a, b)| }
* 5. OR has the form { |(a, b), c| }
*
* then we check if the one argument is an Array. If it is not, call
* #to_ary to convert it to an Array and raise if #to_ary does not
* return an Array.
*
* Finally, in cases 1-3, and 5 above, we destructure the Array into
* the block's arguments.
*/
if(total_args == 1
&& (mcode->required_args > 1
|| (mcode->required_args == 1
&& (has_splat || mcode->splat_position < -2)))) {
Object* obj = args.get_argument(0);
Array* ary = 0;
if(!(ary = try_as<Array>(obj))) {
if(CBOOL(obj->respond_to(state, state->symbol("to_ary"), cFalse))) {
obj = obj->send(state, call_frame, state->symbol("to_ary"));
if(!(ary = try_as<Array>(obj))) {
Exception::type_error(state, "to_ary must return an Array", call_frame);
return false;
}
}
}
if(ary) {
if(mcode->splat_position == -4 && mcode->required_args == 1) {
args.use_argument(ary);
} else {
args.use_array(ary);
}
}
}
}
const native_int P = mcode->post_args;
const native_int R = mcode->required_args;
// M is for mandatory
const native_int M = R - P;
const native_int T = args.total();
// DT is for declared total
const native_int DT = mcode->total_args;
const native_int O = DT - R;
// HS is for has splat
const native_int HS = mcode->splat_position >= 0 ? 1 : 0;
// CT is for clamped total
const native_int CT = HS ? T : MIN(T, DT);
// Z is for the available # of post args
const native_int Z = CT - M;
// U is for the available # of optional args
const native_int U = Z - P;
// PAO is for the post-args offset
// PLO is for the post-arg locals offset
const native_int PAO = CT - MIN(Z, P);
const native_int PLO = M + O + HS;
/* There are 4 types of arguments, illustrated here:
* m(a, b=1, *c, d)
*
* where:
* a is a (pre optional/splat) fixed position argument
* b is an optional argument
* c is a splat argument
* d is a post (optional/splat) argument
*
* The arity checking above ensures that we have at least one argument
* on the stack for each fixed position argument (ie arguments a and d
* above).
*
* The number of (pre) fixed arguments is 'required_args - post_args'.
*
* The number of optional arguments is 'total_args - required_args'.
*
* We fill in the required arguments, then the optional arguments, and
* the rest (if any) go into an array for the splat.
*/
// Phase 1, mandatory args
for(native_int i = 0, l = MIN(M,T);
i < l;
i++)
{
scope->set_local(i, args.get_argument(i));
}
// Phase 2, post args
for(native_int i = 0; i < MIN(Z, P); i++)
{
scope->set_local(PLO + i, args.get_argument(PAO + i));
}
// Phase 3, optionals
for(native_int i = M, limit = M + MIN(U, O);
i < limit;
i++)
{
scope->set_local(i, args.get_argument(i));
}
if(has_splat) {
Array* ary;
/* There is a splat. So if the passed in arguments are greater
* than the total number of fixed arguments, put the rest of the
* arguments into the Array.
*
* Otherwise, generate an empty Array.
*
* NOTE: remember that total includes the number of fixed arguments,
* even if they're optional, so we can get args.total() == 0, and
* total == 1 */
int splat_size = T - DT;
if(splat_size > 0) {
ary = Array::create(state, splat_size);
for(int i = 0, n = M + O;
i < splat_size;
i++, n++)
{
ary->set(state, i, args.get_argument(n));
}
} else {
ary = Array::create(state, 0);
}
scope->set_local(mcode->splat_position, ary);
}
return true;
}
/* Constructor */
ListTablesCall(const Arguments &args) :
NativeCFunctionCall_2_<int, SessionImpl *, const char *>(NULL, args),
list(),
isolate(args.GetIsolate())
{
}
/* static */
Handle<Value> MemoryObject::New(const Arguments& args)
{
HandleScope scope;
MemoryObject *cl = new MemoryObject(args.This());
return args.This();
}
static Handle<Value> New(const Arguments &args)
{
Rot13 *rot13 = new Rot13();
rot13->Wrap(args.This());
return args.This();
}
int run(int argc, char* argv[])
{
Arguments args;
args.add("help", 'h').description("Shows this help message.").flag(true);
args.add("input", 'i').description("Input filename").required(true);
args.add("output", 'o').description("Output filename").required(true);
args.add("format", 'f').description("Output format. Overrides file extension.");
args.add("axis", 'x').description("Change axis order of the cordinate system and polarity. (like +x+y+z, +x-z+y, ... )");
args.add("textures", 't').description("Strip path from texture filenames").flag(true);
// parse args
if (!args.evaluate(argc, argv)) {
cout << args.getErrorMessage() << endl;
cout << args.getHelpMessage() << endl;
return 1;
}
// print help
if (argc == 1 || args.get("help").isFound()) {
cout << args.getHelpMessage() << endl;
return 0;
}
string inFileName = args.get("input").value();
string outFileName = args.get("output").value();
string outExtension;
// determine file format
if (!args.get("format").isFound())
{
string::size_type n;
string s = outFileName;
n = s.find_last_of('.');
if (n != string::npos) {
s = s.substr(n + 1);
}
if (s.empty()) {
outExtension = "assbin";
cout << "WARNING: No file extension was given. Using assbin format for default." << endl;
}
else {
outExtension = s;
}
}
else {
outExtension = args.get("format").value();
}
// import scene
Assimp::Importer aiImporter;
aiScene const * scene = aiImporter.ReadFile(inFileName.c_str(),
aiProcessPreset_TargetRealtime_Quality |
aiProcess_ConvertToLeftHanded |
0);
if (scene == nullptr) {
cout << "Could not load model file" << inFileName << endl;
cout << aiImporter.GetErrorString() << endl;
return 1;
}
// flip axes
if (args.get("axis").isFound() && scene->HasMeshes()) {
string axesOrder = args.get("axis").value();
if (axesOrder.length() != 6) {
cout << args.getHelpMessage() << endl;
return 1;
}
char order[3];
char polarity[3];
uint k = 3;
while (k--) {
char c = axesOrder.at(2*k), b = -1;
char a = axesOrder.at(2*k+1), d = 1;
switch (a) {
case 'x': case 'X': b = 0; break;
case 'y': case 'Y': b = 1; break;
case 'z': case 'Z': b = 2; break;
default:
cout << args.getHelpMessage() << endl;
return 1;
}
switch (c) {
case '+': d = +1; break;
case '-': d = -1; break;
default:
cout << args.getHelpMessage() << endl;
return 1;
}
order[k] = b;
polarity[k] = d;
}
for (uint i = 0; i < scene->mNumMeshes; i++) {
aiMesh * const mesh = scene->mMeshes[i];
for (uint j = 0; j < mesh->mNumVertices; j++) {
swap_vertices(&mesh->mVertices[j], order, polarity);
swap_vertices(&mesh->mNormals[j], order, polarity);
}
}
}
// strip texture filenames
if (args.get("textures").isFound() && scene->HasMaterials()) {
for (uint i = 0; i < scene->mNumMaterials; i++) {
aiMaterial const * material = scene->mMaterials[i];
for (uint j = 0; j < sizeof(textureTypes) / sizeof(textureTypes[0]); j++) {
aiTextureType tt = textureTypes[j];
for (uint k = 0; k < material->GetTextureCount(tt); k++) {
aiString aiPath;
material->GetTexture(tt, k, &aiPath);
string path = aiPath.C_Str();
{
string s = path;
string::size_type n, m;
n = s.find_last_of('/');
m = s.find_last_of('\\');
if (n != string::npos) {
s = s.substr(n + 1);
}
else if (m != string::npos) {
s = s.substr(m + 1);
}
if (!s.empty()) {
path = s;
}
}
// textura filenev vissza
const aiMaterialProperty* pp = nullptr;
if (aiGetMaterialProperty(material, AI_MATKEY_TEXTURE(tt, k), &pp) == AI_SUCCESS) {
aiMaterialProperty* pProp = const_cast<aiMaterialProperty*>(pp);
if (aiPTI_String == pProp->mType) {
size_t newLen = path.length() + 4;
char* newData = (char*)malloc(newLen);
(*(uint*)(&newData[0])) = path.length();
memcpy_s(&newData[4], newLen, path.c_str(), path.length());
free(pProp->mData);
pProp->mData = newData;
pProp->mDataLength = newLen;
}
}
}
}
}
}
// save
Assimp::Exporter aiExporter;
if (aiExporter.Export(scene, outExtension, outFileName) != aiReturn_SUCCESS) {
cout << "Could not save model file" << endl;
cout << aiExporter.GetErrorString() << endl;
return 1;
}
return 0;
}
Handle<Value> App::New(const Arguments& args) {
HandleScope scope;
App* obj = new App();
obj->Wrap(args.This());
return scope.Close(args.This());
}
int main(int argc, const char* argv[])
{
//
// Parse arguments
//
Arguments arguments;
std::string makeFile("project.pmk");
std::string fbxFile;
bool fromFbx = false; // Create the entire wallpaper from FBX.
for (int i = 1; i < argc; ++i)
{
if (strncmp(argv[i], "-h", 2) == 0)
{
printUsage();
return EXIT_SUCCESS;
}
else if (strncmp(argv[i], "-v", 2) == 0)
{
printVersion();
return EXIT_SUCCESS;
}
else if (strncmp(argv[i], "-f", 2) == 0)
{
i++;
if (i == argc)
{
logError("The project make file is missing!\n");
printUsage();
return EXIT_FAILURE;
}
makeFile = std::string(argv[i]);
}
else
{
if (i == argc - 1)
{
fbxFile = argv[i];
fromFbx = true;
}
else
{
logError("Unknown command line arguments.");
printUsage();
return EXIT_FAILURE;
}
}
}
// Parse the configuration.
if (!fromFbx)
{
if (!arguments.parse(makeFile.c_str()))
{
return EXIT_FAILURE;
}
}
else
{
arguments.fromFbxFile(fbxFile);
}
//
// Delete the old project if exists
//
char cmdline[1024];
#if defined WIN32
sprintf_s(cmdline, 1024, "rd /s /q %s", arguments.shortProjectName.c_str());
system(cmdline);
#endif
//
// Create the project
//
logInfo("Creating the project.");
MakeProject makeProject(arguments);
if (!makeProject.run(fromFbx))
{
return EXIT_FAILURE;
}
logInfo("Project %s has been created!", arguments.projectName.c_str());
//
// Run fbxtool and copy the resource to the application folder.
//
#if defined WIN32
sprintf_s(cmdline, 1024, "fbxtool.exe -meshformat pmh -meshattrib a %s", fbxFile.c_str());
int exitCode = system(cmdline);
sprintf_s(cmdline, 1024, "xcopy /E /i res %s\\application\\res", arguments.shortProjectName.c_str());
system(cmdline);
system("rd /s /q res");
#endif
// If debugger is present, a pause is required to keep the console output
// visible. Otherwise the pause is automatic.
if (IsDebuggerPresent())
{
system("pause");
}
return EXIT_SUCCESS;
}
Handle<Value> TiTitaniumObject::_globalInclude(void*, TiObject*, const Arguments& args)
{
if (args.Length() < 2)
{
return ThrowException(String::New(Ti::Msg::Missing_argument));
}
string id = *String::Utf8Value(args[0]->ToString());
string parentFolder = *String::Utf8Value(args[1]->ToString());
// CommonJS path rules
if (id.find("/") == 0) {
id.replace(id.find("/"), std::string("/").length(), rootFolder);
}
else if (id.find("./") == 0) {
id.replace(id.find("./"), std::string("./").length(), parentFolder);
}
else if (id.find("../") == 0) {
// count ../../../ in id and strip off back of parentFolder
int count = 0;
size_t idx = 0;
size_t pos = 0;
while (true) {
idx = id.find("../", pos);
if (idx == std::string::npos) {
break;
} else {
pos = idx + 3;
count++;
}
}
// strip leading ../../ off module id
id = id.substr(pos);
// strip paths off the parent folder
idx = 0;
pos = parentFolder.size();
for (int i = 0; i < count; i++) {
idx = parentFolder.find_last_of("/", pos);
pos = idx - 1;
}
if (idx == std::string::npos) {
return ThrowException(String::New("Unable to find module"));
}
parentFolder = parentFolder.substr(0, idx + 1);
id = parentFolder + id;
}
else {
string tempId = rootFolder + id;
ifstream ifs((tempId).c_str());
if (!ifs) {
id = parentFolder + id;
}
else {
id = rootFolder + id;
}
}
string filename = id;
string javascript;
{
ifstream ifs((filename).c_str());
if (!ifs)
{
Local<Value> taggedMessage = String::New((string(Ti::Msg::No_such_native_module) + " " + id).c_str());
return ThrowException(taggedMessage);
}
getline(ifs, javascript, string::traits_type::to_char_type(string::traits_type::eof()));
ifs.close();
}
// wrap the module
{
size_t idx = filename.find_last_of("/");
parentFolder = filename.substr(0, idx + 1);
static const string preWrap = "Ti.include = function (id) { Ti.globalInclude(id, '" + parentFolder + "')};\n";
javascript = preWrap + javascript;
}
TryCatch tryCatch;
Handle<Script> compiledScript = Script::Compile(String::New(javascript.c_str()), String::New(filename.c_str()));
if (compiledScript.IsEmpty())
{
DisplayExceptionLine(tryCatch);
return tryCatch.ReThrow();
}
Persistent<Value> result = Persistent<Value>::New(compiledScript->Run());
if (result.IsEmpty())
{
return tryCatch.ReThrow();
}
return Undefined();
}
inline void debug_ast(AST_Node* node, std::string ind, Env* env)
{
if (node == 0) return;
if (ind == "") std::cerr << "####################################################################\n";
if (dynamic_cast<Bubble*>(node)) {
Bubble* bubble = dynamic_cast<Bubble*>(node);
std::cerr << ind << "Bubble " << bubble;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << bubble->tabs();
std::cerr << std::endl;
debug_ast(bubble->node(), ind + " ", env);
} else if (dynamic_cast<Trace*>(node)) {
Trace* trace = dynamic_cast<Trace*>(node);
std::cerr << ind << "Trace " << trace;
std::cerr << " (" << pstate_source_position(node) << ")"
<< " [name:" << trace->name() << "]"
<< std::endl;
debug_ast(trace->block(), ind + " ", env);
} else if (dynamic_cast<At_Root_Block*>(node)) {
At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
std::cerr << ind << "At_Root_Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << root_block->tabs();
std::cerr << std::endl;
debug_ast(root_block->expression(), ind + ":", env);
debug_ast(root_block->block(), ind + " ", env);
} else if (dynamic_cast<CommaSequence_Selector*>(node)) {
CommaSequence_Selector* selector = dynamic_cast<CommaSequence_Selector*>(node);
std::cerr << ind << "CommaSequence_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->is_invisible() ? " [INVISIBLE]": " -");
std::cerr << (selector->has_placeholder() ? " [PLACEHOLDER]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
// } else if (dynamic_cast<Expression*>(node)) {
// Expression* expression = dynamic_cast<Expression*>(node);
// std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
} else if (dynamic_cast<Parent_Selector*>(node)) {
Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
std::cerr << ind << "Parent_Selector " << selector;
// if (selector->not_selector()) cerr << " [in_declaration]";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [" << (selector->is_real_parent_ref() ? "REAL" : "FAKE") << "]";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
// debug_ast(selector->selector(), ind + "->", env);
} else if (dynamic_cast<Sequence_Selector*>(node)) {
Sequence_Selector* selector = dynamic_cast<Sequence_Selector*>(node);
std::cerr << ind << "Sequence_Selector " << selector
<< " (" << pstate_source_position(node) << ")"
<< " <" << selector->hash() << ">"
<< " [length:" << longToHex(selector->length()) << "]"
<< " [weight:" << longToHex(selector->specificity()) << "]"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_invisible() ? " [INVISIBLE]": " -")
<< (selector->has_placeholder() ? " [PLACEHOLDER]": " -")
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_parent_ref() ? " [has parent]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< " -- ";
std::string del;
switch (selector->combinator()) {
case Sequence_Selector::PARENT_OF: del = ">"; break;
case Sequence_Selector::PRECEDES: del = "~"; break;
case Sequence_Selector::ADJACENT_TO: del = "+"; break;
case Sequence_Selector::ANCESTOR_OF: del = " "; break;
case Sequence_Selector::REFERENCE: del = "//"; break;
}
// if (del = "/") del += selector->reference()->perform(&to_string) + "/";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
if (selector->tail()) {
debug_ast(selector->tail(), ind + "{" + del + "}", env);
} else if(del != " ") {
std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
}
SourcesSet set = selector->sources();
// debug_sources_set(set, ind + " @--> ");
} else if (dynamic_cast<SimpleSequence_Selector*>(node)) {
SimpleSequence_Selector* selector = dynamic_cast<SimpleSequence_Selector*>(node);
std::cerr << ind << "SimpleSequence_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->extended() ? " [extended]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Wrapped_Selector*>(node)) {
Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
std::cerr << ind << "Wrapped_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->selector(), ind + " () ", env);
} else if (dynamic_cast<Pseudo_Selector*>(node)) {
Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
std::cerr << ind << "Pseudo_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->expression(), ind + " <= ", env);
} else if (dynamic_cast<Attribute_Selector*>(node)) {
Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
std::cerr << ind << "Attribute_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
} else if (dynamic_cast<Class_Selector*>(node)) {
Class_Selector* selector = dynamic_cast<Class_Selector*>(node);
std::cerr << ind << "Class_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Id_Selector*>(node)) {
Id_Selector* selector = dynamic_cast<Id_Selector*>(node);
std::cerr << ind << "Id_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Element_Selector*>(node)) {
Element_Selector* selector = dynamic_cast<Element_Selector*>(node);
std::cerr << ind << "Element_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
std::cerr << std::endl;
} else if (dynamic_cast<Placeholder_Selector*>(node)) {
Placeholder_Selector* selector = dynamic_cast<Placeholder_Selector*>(node);
std::cerr << ind << "Placeholder_Selector [" << selector->ns_name() << "] " << selector
<< " <" << selector->hash() << ">"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Simple_Selector*>(node)) {
Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
std::cerr << ind << "Simple_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
} else if (dynamic_cast<Selector_Schema*>(node)) {
Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
std::cerr << ind << "Selector_Schema " << selector;
std::cerr << " (" << pstate_source_position(node) << ")"
<< (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
debug_ast(selector->contents(), ind + " ");
// for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector*>(node)) {
Selector* selector = dynamic_cast<Selector*>(node);
std::cerr << ind << "Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Media_Query_Expression*>(node)) {
Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
std::cerr << ind << "Media_Query_Expression " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Media_Query*>(node)) {
Media_Query* block = dynamic_cast<Media_Query*>(node);
std::cerr << ind << "Media_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_negated() ? " [is_negated]": " -")
<< (block->is_restricted() ? " [is_restricted]": " -")
<< std::endl;
debug_ast(block->media_type(), ind + " ");
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Media_Block*>(node)) {
Media_Block* block = dynamic_cast<Media_Block*>(node);
std::cerr << ind << "Media_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " =@ ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Supports_Block*>(node)) {
Supports_Block* block = dynamic_cast<Supports_Block*>(node);
std::cerr << ind << "Supports_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->condition(), ind + " =@ ");
debug_ast(block->block(), ind + " <>");
} else if (dynamic_cast<Supports_Operator*>(node)) {
Supports_Operator* block = dynamic_cast<Supports_Operator*>(node);
std::cerr << ind << "Supports_Operator " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->left(), ind + " left) ");
debug_ast(block->right(), ind + " right) ");
} else if (dynamic_cast<Supports_Negation*>(node)) {
Supports_Negation* block = dynamic_cast<Supports_Negation*>(node);
std::cerr << ind << "Supports_Negation " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->condition(), ind + " condition) ");
} else if (dynamic_cast<At_Root_Query*>(node)) {
At_Root_Query* block = dynamic_cast<At_Root_Query*>(node);
std::cerr << ind << "At_Root_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Supports_Declaration*>(node)) {
Supports_Declaration* block = dynamic_cast<Supports_Declaration*>(node);
std::cerr << ind << "Supports_Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Block*>(node)) {
Block* root_block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
if (root_block->is_root()) std::cerr << " [root]";
std::cerr << " " << root_block->tabs() << std::endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Warning*>(node)) {
Warning* block = dynamic_cast<Warning*>(node);
std::cerr << ind << "Warning " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->message(), ind + " : ");
} else if (dynamic_cast<Error*>(node)) {
Error* block = dynamic_cast<Error*>(node);
std::cerr << ind << "Error " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Debug*>(node)) {
Debug* block = dynamic_cast<Debug*>(node);
std::cerr << ind << "Debug " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->value(), ind + " ");
} else if (dynamic_cast<Comment*>(node)) {
Comment* block = dynamic_cast<Comment*>(node);
std::cerr << ind << "Comment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() <<
" <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(block->text(), ind + "// ", env);
} else if (dynamic_cast<If*>(node)) {
If* block = dynamic_cast<If*>(node);
std::cerr << ind << "If " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->predicate(), ind + " = ");
debug_ast(block->block(), ind + " <>");
debug_ast(block->alternative(), ind + " ><");
} else if (dynamic_cast<Return*>(node)) {
Return* block = dynamic_cast<Return*>(node);
std::cerr << ind << "Return " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Extension*>(node)) {
Extension* block = dynamic_cast<Extension*>(node);
std::cerr << ind << "Extension " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "-> ", env);
} else if (dynamic_cast<Content*>(node)) {
Content* block = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [@media:" << block->media_block() << "]";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import_Stub*>(node)) {
Import_Stub* block = dynamic_cast<Import_Stub*>(node);
std::cerr << ind << "Import_Stub " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->imp_path() << "] ";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import*>(node)) {
Import* block = dynamic_cast<Import*>(node);
std::cerr << ind << "Import " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
// std::vector<std::string> files_;
for (auto imp : block->urls()) debug_ast(imp, ind + "@: ", env);
debug_ast(block->media_queries(), ind + "@@ ");
} else if (dynamic_cast<Assignment*>(node)) {
Assignment* block = dynamic_cast<Assignment*>(node);
std::cerr << ind << "Assignment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <<" << block->variable() << ">> " << block->tabs() << std::endl;
debug_ast(block->value(), ind + "=", env);
} else if (dynamic_cast<Declaration*>(node)) {
Declaration* block = dynamic_cast<Declaration*>(node);
std::cerr << ind << "Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->property(), ind + " prop: ", env);
debug_ast(block->value(), ind + " value: ", env);
debug_ast(block->block(), ind + " ", env);
} else if (dynamic_cast<Keyframe_Rule*>(node)) {
Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
std::cerr << ind << "Keyframe_Rule " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Directive*>(node)) {
Directive* block = dynamic_cast<Directive*>(node);
std::cerr << ind << "Directive " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "~", env);
debug_ast(block->value(), ind + "+", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Each*>(node)) {
Each* block = dynamic_cast<Each*>(node);
std::cerr << ind << "Each " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<For*>(node)) {
For* block = dynamic_cast<For*>(node);
std::cerr << ind << "For " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<While*>(node)) {
While* block = dynamic_cast<While*>(node);
std::cerr << ind << "While " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Definition*>(node)) {
Definition* block = dynamic_cast<Definition*>(node);
std::cerr << ind << "Definition " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << block->name() << "] ";
std::cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
// this seems to lead to segfaults some times?
// std::cerr << " [signature: " << block->signature() << "] ";
std::cerr << " [native: " << block->native_function() << "] ";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->parameters(), ind + " params: ", env);
if (block->block()) debug_ast(block->block(), ind + " ", env);
} else if (dynamic_cast<Mixin_Call*>(node)) {
Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
std::cerr << ind << "Mixin_Call " << block << " " << block->tabs();
std::cerr << " [" << block->name() << "]";
std::cerr << " [has_content: " << block->has_content() << "] " << std::endl;
debug_ast(block->arguments(), ind + " args: ");
if (block->block()) debug_ast(block->block(), ind + " ", env);
} else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
std::cerr << ind << "Ruleset " << ruleset;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << ruleset->tabs() << "]";
std::cerr << (ruleset->is_invisible() ? " [INVISIBLE]" : "");
std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
std::cerr << (ruleset->is_root() ? " [root]" : "");
std::cerr << std::endl;
debug_ast(ruleset->selector(), ind + ">");
debug_ast(ruleset->block(), ind + " ");
} else if (dynamic_cast<Block*>(node)) {
Block* block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_invisible() ? " [INVISIBLE]" : "");
std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Textual*>(node)) {
Textual* expression = dynamic_cast<Textual*>(node);
std::cerr << ind << "Textual ";
if (expression->type() == Textual::NUMBER) std::cerr << " [NUMBER]";
else if (expression->type() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
else if (expression->type() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
else if (expression->type() == Textual::HEX) std::cerr << " [HEX]";
std::cerr << expression << " [" << expression->value() << "]";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << std::endl;
} else if (dynamic_cast<Variable*>(node)) {
Variable* expression = dynamic_cast<Variable*>(node);
std::cerr << ind << "Variable " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]" << std::endl;
std::string name(expression->name());
if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
} else if (dynamic_cast<Function_Call_Schema*>(node)) {
Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
std::cerr << ind << "Function_Call_Schema " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << "" << std::endl;
debug_ast(expression->name(), ind + "name: ", env);
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Function_Call*>(node)) {
Function_Call* expression = dynamic_cast<Function_Call*>(node);
std::cerr << ind << "Function_Call " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << std::endl;
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Arguments*>(node)) {
Arguments* expression = dynamic_cast<Arguments*>(node);
std::cerr << ind << "Arguments " << expression;
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->has_named_arguments()) std::cerr << " [has_named_arguments]";
if (expression->has_rest_argument()) std::cerr << " [has_rest_argument]";
if (expression->has_keyword_argument()) std::cerr << " [has_keyword_argument]";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Argument*>(node)) {
Argument* expression = dynamic_cast<Argument*>(node);
std::cerr << ind << "Argument " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->value() << "]";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [rest: " << expression->is_rest_argument() << "] ";
std::cerr << " [keyword: " << expression->is_keyword_argument() << "] " << std::endl;
debug_ast(expression->value(), ind + " value: ", env);
} else if (dynamic_cast<Parameters*>(node)) {
Parameters* expression = dynamic_cast<Parameters*>(node);
std::cerr << ind << "Parameters " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
std::cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Parameter*>(node)) {
Parameter* expression = dynamic_cast<Parameter*>(node);
std::cerr << ind << "Parameter " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [default: " << expression->default_value() << "] ";
std::cerr << " [rest: " << expression->is_rest_parameter() << "] " << std::endl;
} else if (dynamic_cast<Unary_Expression*>(node)) {
Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
std::cerr << ind << "Unary_Expression " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type() << "]" << std::endl;
debug_ast(expression->operand(), ind + " operand: ", env);
} else if (dynamic_cast<Binary_Expression*>(node)) {
Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
std::cerr << ind << "Binary_Expression " << expression;
if (expression->is_interpolant()) std::cerr << " [is interpolant] ";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [ws_before: " << expression->op().ws_before << "] ";
std::cerr << " [ws_after: " << expression->op().ws_after << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type_name() << "]" << std::endl;
debug_ast(expression->left(), ind + " left: ", env);
debug_ast(expression->right(), ind + " right: ", env);
} else if (dynamic_cast<Map*>(node)) {
Map* expression = dynamic_cast<Map*>(node);
std::cerr << ind << "Map " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Hashed]" << std::endl;
for (auto i : expression->elements()) {
debug_ast(i.first, ind + " key: ");
debug_ast(i.second, ind + " val: ");
}
} else if (dynamic_cast<List*>(node)) {
List* expression = dynamic_cast<List*>(node);
std::cerr << ind << "List " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " (" << expression->length() << ") " <<
(expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
" [delayed: " << expression->is_delayed() << "] " <<
" [interpolant: " << expression->is_interpolant() << "] " <<
" [listized: " << expression->from_selector() << "] " <<
" [arglist: " << expression->is_arglist() << "] " <<
" [hash: " << expression->hash() << "] " <<
std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Content*>(node)) {
Content* expression = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [@media:" << expression->media_block() << "]";
std::cerr << " [Statement]" << std::endl;
} else if (dynamic_cast<Boolean*>(node)) {
Boolean* expression = dynamic_cast<Boolean*>(node);
std::cerr << ind << "Boolean " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << "]" << std::endl;
} else if (dynamic_cast<Color*>(node)) {
Color* expression = dynamic_cast<Color*>(node);
std::cerr << ind << "Color " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << std::endl;
} else if (dynamic_cast<Number*>(node)) {
Number* expression = dynamic_cast<Number*>(node);
std::cerr << ind << "Number " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << expression->unit() << "]" <<
" [hash: " << expression->hash() << "] " <<
std::endl;
} else if (dynamic_cast<String_Quoted*>(node)) {
String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
std::cerr << ind << "String_Quoted " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Constant*>(node)) {
String_Constant* expression = dynamic_cast<String_Constant*>(node);
std::cerr << ind << "String_Constant " << expression;
if (expression->concrete_type()) {
std::cerr << " " << expression->concrete_type();
}
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Schema*>(node)) {
String_Schema* expression = dynamic_cast<String_Schema*>(node);
std::cerr << ind << "String_Schema " << expression;
std::cerr << " " << expression->concrete_type();
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [is interpolant]";
if (expression->has_interpolant()) std::cerr << " [has interpolant]";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<String*>(node)) {
String* expression = dynamic_cast<String*>(node);
std::cerr << ind << "String " << expression;
std::cerr << " " << expression->concrete_type();
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<Expression*>(node)) {
Expression* expression = dynamic_cast<Expression*>(node);
std::cerr << ind << "Expression " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
switch (expression->concrete_type()) {
case Expression::Concrete_Type::NONE: std::cerr << " [NONE]"; break;
case Expression::Concrete_Type::BOOLEAN: std::cerr << " [BOOLEAN]"; break;
case Expression::Concrete_Type::NUMBER: std::cerr << " [NUMBER]"; break;
case Expression::Concrete_Type::COLOR: std::cerr << " [COLOR]"; break;
case Expression::Concrete_Type::STRING: std::cerr << " [STRING]"; break;
case Expression::Concrete_Type::LIST: std::cerr << " [LIST]"; break;
case Expression::Concrete_Type::MAP: std::cerr << " [MAP]"; break;
case Expression::Concrete_Type::SELECTOR: std::cerr << " [SELECTOR]"; break;
case Expression::Concrete_Type::NULL_VAL: std::cerr << " [NULL_VAL]"; break;
case Expression::Concrete_Type::C_WARNING: std::cerr << " [C_WARNING]"; break;
case Expression::Concrete_Type::C_ERROR: std::cerr << " [C_ERROR]"; break;
case Expression::Concrete_Type::NUM_TYPES: std::cerr << " [NUM_TYPES]"; break;
}
std::cerr << std::endl;
} else if (dynamic_cast<Has_Block*>(node)) {
Has_Block* has_block = dynamic_cast<Has_Block*>(node);
std::cerr << ind << "Has_Block " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Statement*>(node)) {
Statement* statement = dynamic_cast<Statement*>(node);
std::cerr << ind << "Statement " << statement;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << statement->tabs() << std::endl;
}
if (ind == "") std::cerr << "####################################################################\n";
}
Handle<Value> Query::New(Arguments const& args)
{
HandleScope scope;
if (!args.IsConstructCall()) {
return ThrowException(Exception::Error(String::New("Cannot call constructor as function, you need to use 'new' keyword")));
}
try {
if (args.Length() != 1) {
return ThrowException(Exception::TypeError(String::New("please provide an object of options for the first argument")));
}
if (!args[0]->IsObject()) {
return ThrowException(Exception::TypeError(String::New("first argument must be an object")));
}
Local<Object> obj = args[0]->ToObject();
if (obj->IsNull() || obj->IsUndefined()) {
return ThrowException(Exception::TypeError(String::New("first arg must be an object")));
}
if (!obj->Has(String::New("coordinates"))) {
return ThrowException(Exception::TypeError(String::New("must provide a coordinates property")));
}
Local<Value> coordinates = obj->Get(String::New("coordinates"));
if (!coordinates->IsArray()) {
return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs")));
}
// Handle scenario in which caller explicitly specified service
std::string service;
if (obj->Has(String::New("service"))) {
Local<Value> serviceValue = obj->Get(String::New("service"));
v8::String::Utf8Value serviceUtf8Value(serviceValue->ToString());
service = std::string(*serviceUtf8Value);
}
// Handle 'nearest', otherwise assume 'viaroute' service.
if (service == "nearest" || service == "locate") {
Local<Array> coordinates_array = Local<Array>::Cast(coordinates);
if (coordinates_array->Length() != 1) {
return ThrowException(Exception::TypeError(String::New("coordinates array should only have one lat/long pair for 'nearest' or 'locate' queries")));
}
Local<Value> coordinate = coordinates_array->Get(0);
if (!coordinate->IsArray()) {
return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs")));
}
Local<Array> coordinate_array = Local<Array>::Cast(coordinate);
if (coordinate_array->Length() != 2) {
return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs")));
}
Query* q = new Query();
q->this_->service = service;
q->this_->coordinates.push_back(
FixedPointCoordinate(coordinate_array->Get(0)->NumberValue()*COORDINATE_PRECISION,
coordinate_array->Get(1)->NumberValue()*COORDINATE_PRECISION));
q->Wrap(args.This());
return args.This();
}
Local<Array> coordinates_array = Local<Array>::Cast(coordinates);
if (coordinates_array->Length() < 2) {
return ThrowException(Exception::TypeError(String::New("at least two coordinates must be provided")));
}
Query* q = new Query();
q->this_->zoomLevel = 18; //no generalization
q->this_->printInstructions = false; //turn by turn instructions
q->this_->alternateRoute = true; //get an alternate route, too
q->this_->geometry = true; //retrieve geometry of route
q->this_->compression = true; //polyline encoding
q->this_->checkSum = UINT_MAX; //see wiki
q->this_->service = "viaroute"; //that's routing
q->this_->outputFormat = "json";
q->this_->jsonpParameter = ""; //set for jsonp wrapping
q->this_->language = ""; //unused atm
if (obj->Has(String::New("alternateRoute"))) {
q->this_->alternateRoute = obj->Get(String::New("alternateRoute"))->BooleanValue();
}
if (obj->Has(String::New("checksum"))) {
q->this_->checkSum = static_cast<unsigned>(obj->Get(String::New("checksum"))->Uint32Value());
}
if (obj->Has(String::New("zoomLevel"))) {
q->this_->zoomLevel = static_cast<short>(obj->Get(String::New("zoomLevel"))->Int32Value());
}
if (obj->Has(String::New("printInstructions"))) {
q->this_->printInstructions = obj->Get(String::New("printInstructions"))->BooleanValue();
}
if (obj->Has(String::New("jsonpParameter"))) {
q->this_->jsonpParameter = *v8::String::Utf8Value(obj->Get(String::New("jsonpParameter")));
}
if (obj->Has(String::New("hints"))) {
Local<Value> hints = obj->Get(String::New("hints"));
if (!hints->IsArray()) {
return ThrowException(Exception::TypeError(String::New("hints must be an array of strings/null")));
}
Local<Array> hints_array = Local<Array>::Cast(hints);
for (uint32_t i = 0; i < hints_array->Length(); ++i) {
Local<Value> hint = hints_array->Get(i);
if (hint->IsString()) {
q->this_->hints.push_back(*v8::String::Utf8Value(hint));
} else if(hint->IsNull()){
q->this_->hints.push_back("");
}else{
return ThrowException(Exception::TypeError(String::New("hint must be null or string")));
}
}
}
for (uint32_t i = 0; i < coordinates_array->Length(); ++i) {
Local<Value> coordinate = coordinates_array->Get(i);
if (!coordinate->IsArray()) {
return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs")));
}
Local<Array> coordinate_array = Local<Array>::Cast(coordinate);
if (coordinate_array->Length() != 2) {
return ThrowException(Exception::TypeError(String::New("coordinates must be an array of (lat/long) pairs")));
}
q->this_->coordinates.push_back(
FixedPointCoordinate(coordinate_array->Get(0)->NumberValue()*COORDINATE_PRECISION,
coordinate_array->Get(1)->NumberValue()*COORDINATE_PRECISION));
}
q->Wrap(args.This());
return args.This();
} catch (std::exception const& ex) {
return ThrowException(Exception::TypeError(String::New(ex.what())));
}
return Undefined();
}
Handle<Value> Connection::SetAutoCommit(const Arguments& args) {
Connection* connection = ObjectWrap::Unwrap<Connection>(args.This());
REQ_BOOL_ARG(0, autoCommit);
connection->m_autoCommit = autoCommit;
return Undefined();
}
Handle<Value> DispObject::NodeToString(const Arguments& args)
{
DispObject *me = DispObject::Unwrap<DispObject>(args.This());
if (!me) return Undefined();
return me->toString();
}
Handle<Value> Window::Fullscreen(const Arguments& args) {
HandleScope scope;
NativeWindow *window = ObjectWrap::Unwrap<NativeWindow>(args.This());
window->Fullscreen();
return scope.Close(args.This());
}
Handle<Value> HoneydProfileBinding::Save(const Arguments& args)
{
if(args.Length() != 2)
{
return ThrowException(Exception::TypeError(String::New("Must be invoked with at exactly two parameters")));
}
HandleScope scope;
HoneydProfileBinding* obj = ObjectWrap::Unwrap<HoneydProfileBinding>(args.This());
std::string oldName = cvv8::CastFromJS<std::string>(args[0]);
bool addOrEdit = cvv8::CastFromJS<bool>(args[1]);
HoneydConfiguration *conf = new HoneydConfiguration();
conf->LoadAllTemplates();
if(addOrEdit)
{
conf->AddProfile(obj->m_pfile);
}
else
{
conf->m_profiles[oldName].SetTcpAction(obj->m_pfile->m_tcpAction);
conf->m_profiles[oldName].SetUdpAction(obj->m_pfile->m_udpAction);
conf->m_profiles[oldName].SetIcmpAction(obj->m_pfile->m_icmpAction);
conf->m_profiles[oldName].SetPersonality(obj->m_pfile->m_personality);
conf->m_profiles[oldName].SetUptimeMin(obj->m_pfile->m_uptimeMin);
conf->m_profiles[oldName].SetUptimeMax(obj->m_pfile->m_uptimeMax);
conf->m_profiles[oldName].SetDropRate(obj->m_pfile->m_dropRate);
conf->m_profiles[oldName].SetParentProfile(obj->m_pfile->m_parentProfile);
conf->m_profiles[oldName].SetVendors(obj->m_pfile->m_ethernetVendors);
conf->m_profiles[oldName].setTcpActionInherited(obj->m_pfile->isTcpActionInherited());
conf->m_profiles[oldName].setUdpActionInherited(obj->m_pfile->isUdpActionInherited());
conf->m_profiles[oldName].setIcmpActionInherited(obj->m_pfile->isIcmpActionInherited());
conf->m_profiles[oldName].setPersonalityInherited(obj->m_pfile->isPersonalityInherited());
conf->m_profiles[oldName].setEthernetInherited(obj->m_pfile->isEthernetInherited());
conf->m_profiles[oldName].setUptimeInherited(obj->m_pfile->isUptimeInherited());
conf->m_profiles[oldName].setDropRateInherited(obj->m_pfile->isDropRateInherited());
conf->m_profiles[oldName].SetGenerated(obj->m_pfile->m_generated);
conf->m_profiles[oldName].SetDistribution(obj->m_pfile->m_distribution);
std::vector<std::string> portNames = conf->m_profiles[oldName].GetPortNames();
for(uint i = 0; i < obj->m_pfile->m_ports.size(); i++)
{
bool push = true;
for(uint j = 0; j < portNames.size(); j++)
{
if(!portNames[j].compare(obj->m_pfile->m_ports[i].first))
{
push = false;
}
}
if(push)
{
conf->m_profiles[oldName].m_ports.push_back(obj->m_pfile->m_ports[i]);
push = false;
}
}
conf->UpdateProfile("default");
if(!conf->RenameProfile(oldName, obj->m_pfile->m_name))
{
std::cout << "Couldn't rename profile " << oldName << " to " << obj->m_pfile->m_name << std::endl;
}
}
conf->SaveAllTemplates();
delete conf;
return scope.Close(Boolean::New(true));
}
static bool call(STATE, MachineCode* mcode, StackVariables* scope, Arguments& args) {
return args.total() == 0;
}
/* zipfile.replaceFile(nameInArchive, name, offset, len) */
Handle<Value> ZipFile::Replace_File(const Arguments& args)
{
ZipFile* zf = ObjectWrap::Unwrap<ZipFile>(args.This());
struct zip_source *source;
if (zf->Busy())
return ThrowException(Exception::Error(String::New("Zipfile already in use..")));
if (!args[0]->IsString())
return ThrowException(Exception::TypeError(
String::New("Argument must be a file name.")));
std::string archive_file = TOSTR(args[0]);
std::string name;
if (args[1]->IsUndefined())
name = archive_file;
else
if (!args[1]->IsString())
return ThrowException(Exception::TypeError(
String::New("Argument must be a file name.")));
name = TOSTR(args[1]);
zip_int64_t off;
if (args[2]->IsUndefined())
off = 0;
else
off = args[2]->Int32Value();
zip_int64_t len;
if (args[3]->IsUndefined())
len = -1;
else
len = args[3]->Int32Value();
int idx = -1;
std::vector<std::string>::iterator it = std::find(zf->names.begin(), zf->names.end(), archive_file);
if (it!=zf->names.end()) {
idx = distance(zf->names.begin(), it);
}
if (idx == -1) {
std::stringstream s;
s << "No file found by the name of: '" << archive_file << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
source = zip_source_file(zf->archive, name.c_str(), off, len);
if (source == NULL) {
std::stringstream s;
s << "Error while replacing file " << name << " in zip archive: " << zip_strerror(zf->archive) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
int ret = zip_replace(zf->archive, idx, source);
if (ret < 0) {
zip_source_free(source);
std::stringstream s;
s << "Error while replacing file " << name << " in zip archive: " << zip_strerror(zf->archive) << "\n";
return ThrowException(Exception::Error(String::New(s.str().c_str())));
}
return Undefined();
}
static bool call(STATE, MachineCode* mcode, StackVariables* scope, Arguments& args) {
if(args.total() != 2) return false;
scope->set_local(0, args.get_argument(0));
scope->set_local(1, args.get_argument(1));
return true;
}
Handle<Value> QuaternionToString(const Arguments& args) {
Handle<Object> self = args.This();
QuaternionCheckAndExtract(self_val, self);
String self_val_str = self_val.toString();
return v8::String::New( self_val_str.c_str(), self_val_str.size() );
}
static bool call(STATE, MachineCode* mcode, StackVariables* scope, Arguments& args) {
const bool has_splat = (mcode->splat_position >= 0);
native_int total_args = args.total();
// expecting 0, got 0.
if(mcode->total_args == 0 && total_args == 0) {
if(has_splat) {
scope->set_local(mcode->splat_position, Array::create(state, 0));
}
return true;
}
// Too few args!
if(total_args < mcode->required_args) return false;
// Too many args (no splat!)
if(!has_splat && total_args > mcode->total_args) return false;
/* There are 4 types of arguments, illustrated here:
* m(a, b=1, *c, d)
*
* where:
* a is a (pre optional/splat) fixed position argument
* b is an optional argument
* c is a splat argument
* d is a post (optional/splat) argument
*
* The arity checking above ensures that we have at least one argument
* on the stack for each fixed position argument (ie arguments a and d
* above).
*
* The number of (pre) fixed arguments is 'required_args - post_args'.
*
* The number of optional arguments is 'total_args - required_args'.
*
* We fill in the required arguments, then the optional arguments, and
* the rest (if any) go into an array for the splat.
*/
const native_int P = mcode->post_args;
const native_int R = mcode->required_args;
// M is for mandatory
const native_int M = R - P;
const native_int T = total_args;
// DT is for declared total
const native_int DT = mcode->total_args;
const native_int O = DT - R;
// HS is for has splat
const native_int HS = has_splat ? 1 : 0;
// Phase 1, mandatory args
for(native_int i = 0; i < M; i++) {
scope->set_local(i, args.get_argument(i));
}
// Phase 2, post args
for(native_int i = T - P, l = M + O + HS;
i < T;
i++, l++)
{
scope->set_local(l, args.get_argument(i));
}
// Phase 3, optionals
for(native_int i = M, limit = M + MIN(O, T-R);
i < limit;
i++)
{
scope->set_local(i, args.get_argument(i));
}
// Phase 4, splat
if(has_splat) {
Array* ary;
/* There is a splat. So if the passed in arguments are greater
* than the total number of fixed arguments, put the rest of the
* arguments into the Array.
*
* Otherwise, generate an empty Array.
*
* NOTE: remember that total includes the number of fixed arguments,
* even if they're optional, so we can get args.total() == 0, and
* total == 1 */
int splat_size = T - DT;
if(splat_size > 0) {
ary = Array::create(state, splat_size);
for(int i = 0, n = M + O;
i < splat_size;
i++, n++)
{
ary->set(state, i, args.get_argument(n));
}
} else {
ary = Array::create(state, 0);
}
scope->set_local(mcode->splat_position, ary);
}
return true;
}
Handle<Value> WKTWriter::SetRoundingPrecision(const Arguments& args) {
WKTWriter *writer = ObjectWrap::Unwrap<WKTWriter>(args.This());
writer->_writer->setRoundingPrecision(args[0]->Int32Value());
return Undefined();
}
TEST(AppName, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object.appName(), "AppName");
}