[[ Script ]] Added module querying APIs for events, properties, and dependencies.

runrevmark · runrevmark · commit e222f1e096c6 · 2014-12-04T11:16:00.000Z
diff --git a/libscript/include/script.h b/libscript/include/script.h
@@ -143,21 +143,38 @@ bool MCScriptLookupModule(MCNameRef name, MCScriptModuleRef& r_module);
 bool MCScriptEnsureModuleIsUsable(MCScriptModuleRef module);
 
 // List the module's direct dependencies.
-bool MCScriptGetDependenciesOfModule(MCScriptModuleRef module, const MCNameRef*& r_dependencies, uindex_t& r_count);
+bool MCScriptCopyDependenciesOfModule(MCScriptModuleRef module, /* copy */ MCProperListRef& r_module_names);
 
-// Create an instance of the given module. If the module is single-instance it
-// returns that instance. Otherwise it returns a new instance. If the method
-// fails, false is returned. In the case of success, the caller must release the
-// instance.
-bool MCScriptCreateInstanceOfModule(MCScriptModuleRef module, MCScriptInstanceRef& r_instance);
+// Returns a list of properties implemented by the module.
+bool MCScriptCopyPropertiesOfModule(MCScriptModuleRef module, /* copy */ MCProperListRef& r_property_names);
+
+// Queries the type of the given property. If the setting type is nil, then the property
+// is read-only.
+bool MCScriptQueryPropertyOfModule(MCScriptModuleRef module, MCNameRef property, /* get */ MCTypeInfoRef& r_getter, /* get */ MCTypeInfoRef& r_setter);
+
+// Returns a list of the events declared by the module.
+bool MCScriptCopyEventsOfModule(MCScriptModuleRef module, /* copy */ MCProperListRef& r_event_names);
+
+// Query the signature of the given event.
+bool MCScriptQueryEventOfModule(MCScriptModuleRef module, MCNameRef event, /* get */ MCTypeInfoRef& r_signature);
 
 // Retain a module.
 MCScriptModuleRef MCScriptRetainModule(MCScriptModuleRef module);
+
 // Release a module.
 void MCScriptReleaseModule(MCScriptModuleRef module);
 
+////////////////////////////////////////////////////////////////////////////////
+
+// Create an instance of the given module. If the module is single-instance it
+// returns that instance. Otherwise it returns a new instance. If the method
+// fails, false is returned. In the case of success, the caller must release the
+// instance.
+bool MCScriptCreateInstanceOfModule(MCScriptModuleRef module, MCScriptInstanceRef& r_instance);
+
 // Retain a instance.
 MCScriptInstanceRef MCScriptRetainInstance(MCScriptInstanceRef instance);
+
 // Release a instance.
 void MCScriptReleaseInstance(MCScriptInstanceRef instance);
 
diff --git a/libscript/src/script-module.cpp b/libscript/src/script-module.cpp
@@ -614,6 +614,112 @@ bool MCScriptEnsureModuleIsUsable(MCScriptModuleRef self)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+bool MCScriptCopyDependenciesOfModule(MCScriptModuleRef self, /* copy */ MCProperListRef& r_module_names)
+{
+    MCAutoProperListRef t_modules;
+    if (!MCProperListCreateMutable(&t_modules))
+        return false;
+    
+    for(uindex_t i = 0; i < self -> dependency_count; i++)
+        if (!MCProperListPushElementOntoBack(*t_modules, self -> dependencies[i] . name))
+            return false;
+    
+    if (!MCProperListCopy(*t_modules, r_module_names))
+        return false;
+    
+    return true;
+}
+
+bool MCScriptCopyPropertiesOfModule(MCScriptModuleRef self, /* copy */ MCProperListRef& r_property_names)
+{
+    MCAutoProperListRef t_props;
+    if (!MCProperListCreateMutable(&t_props))
+        return false;
+    
+    for(uindex_t i = 0; i < self -> exported_definition_count; i++)
+        if (self -> definitions[self -> exported_definitions[i] . index] -> kind == kMCScriptDefinitionKindProperty)
+            if (!MCProperListPushElementOntoBack(*t_props, self -> exported_definitions[i] . name))
+                return false;
+    
+    if (!MCProperListCopy(*t_props, r_property_names))
+        return false;
+    
+    return true;
+}
+
+bool MCScriptQueryPropertyOfModule(MCScriptModuleRef self, MCNameRef p_property, /* get */ MCTypeInfoRef& r_getter, /* get */ MCTypeInfoRef& r_setter)
+{
+    MCScriptPropertyDefinition *t_def;
+    
+    if (!self -> is_usable)
+        return false; // TODO - throw error
+    
+    if (!MCScriptLookupPropertyDefinitionInModule(self, p_property, t_def))
+        return false; // TODO - throw error
+    
+    MCScriptDefinition *t_getter;
+    t_getter = t_def -> getter != 0 ? self -> definitions[t_def -> getter - 1] : nil;
+    
+    if (t_getter != nil)
+    {
+        if (t_getter -> kind == kMCScriptDefinitionKindVariable)
+            r_getter = self -> types[static_cast<MCScriptVariableDefinition *>(t_getter) -> type] -> typeinfo;
+        else
+            r_getter = MCHandlerTypeInfoGetReturnType(self -> types[static_cast<MCScriptHandlerDefinition *>(t_getter) -> type] -> typeinfo);
+    }
+    else
+        r_getter = nil;
+    
+    MCScriptDefinition *t_setter;
+    t_setter = t_def -> setter != 0 ? self -> definitions[t_def -> setter - 1] : nil;
+    
+    if (t_setter != nil)
+    {
+        if (t_setter -> kind == kMCScriptDefinitionKindVariable)
+            r_setter = self -> types[static_cast<MCScriptVariableDefinition *>(t_setter) -> type] -> typeinfo;
+        else
+            r_setter = MCHandlerTypeInfoGetParameterType(self -> types[static_cast<MCScriptHandlerDefinition *>(t_setter) -> type] -> typeinfo, 0);
+    }
+    else
+        r_setter = nil;
+    
+    return true;
+}
+
+bool MCScriptCopyEventsOfModule(MCScriptModuleRef self, /* copy */ MCProperListRef& r_event_names)
+{
+    MCAutoProperListRef t_events;
+    if (!MCProperListCreateMutable(&t_events))
+        return false;
+    
+    for(uindex_t i = 0; i < self -> exported_definition_count; i++)
+        if (self -> definitions[self -> exported_definitions[i] . index] -> kind == kMCScriptDefinitionKindEvent)
+            if (!MCProperListPushElementOntoBack(*t_events, self -> exported_definitions[i] . name))
+                return false;
+    
+    if (!MCProperListCopy(*t_events, r_event_names))
+        return false;
+    
+    return true;
+}
+
+bool MCScriptQueryEventOfModule(MCScriptModuleRef self, MCNameRef p_event, /* get */ MCTypeInfoRef& r_signature)
+{
+    MCScriptEventDefinition *t_def;
+    
+    if (!self -> is_usable)
+        return false; // TODO - throw error
+    
+    if (!MCScriptLookupEventDefinitionInModule(self, p_event, t_def))
+        return false; // TODO - throw error
+    
+    r_signature = self -> types[t_def -> type] -> typeinfo;
+    
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 bool MCScriptWriteRawModule(MCStreamRef stream, MCScriptModule *p_module)
 {
     return MCPickleWrite(stream, kMCScriptModulePickleInfo, p_module);
@@ -650,6 +756,25 @@ bool MCScriptLookupPropertyDefinitionInModule(MCScriptModuleRef self, MCNameRef
     return false;
 }
 
+bool MCScriptLookupEventDefinitionInModule(MCScriptModuleRef self, MCNameRef p_property, MCScriptEventDefinition*& r_definition)
+{
+    __MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);
+    
+    for(uindex_t i = 0; i < self -> exported_definition_count; i++)
+    {
+        if (self -> definitions[self -> exported_definitions[i] . index] -> kind != kMCScriptDefinitionKindEvent)
+            continue;
+        
+        if (!MCNameIsEqualTo(p_property, self -> exported_definitions[i] . name))
+            continue;
+        
+        r_definition = static_cast<MCScriptEventDefinition *>(self -> definitions[self -> exported_definitions[i] . index]);
+        return true;
+    }
+    
+    return false;
+}
+
 bool MCScriptLookupHandlerDefinitionInModule(MCScriptModuleRef self, MCNameRef p_handler, MCScriptHandlerDefinition*& r_definition)
 {
     __MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);
diff --git a/libscript/src/script-private.h b/libscript/src/script-private.h
@@ -342,6 +342,7 @@ void MCScriptReleaseRawModule(MCScriptModule *module);
 void MCScriptDestroyModule(MCScriptModuleRef module);
 
 bool MCScriptLookupPropertyDefinitionInModule(MCScriptModuleRef module, MCNameRef property, MCScriptPropertyDefinition*& r_definition);
+bool MCScriptLookupEventDefinitionInModule(MCScriptModuleRef module, MCNameRef property, MCScriptEventDefinition*& r_definition);
 bool MCScriptLookupHandlerDefinitionInModule(MCScriptModuleRef module, MCNameRef handler, MCScriptHandlerDefinition*& r_definition);
 bool MCScriptLookupDefinitionInModule(MCScriptModuleRef self, MCNameRef p_name, MCScriptDefinition*& r_definition);
 
