Skip to content
This repository was archived by the owner on Aug 31, 2021. It is now read-only.

Commit b50dc7a

Browse files
runrevmarkrunrevmark
committed
[[ ExternalsApiV5 ]] Added support for 'not supported' error when handlers are mapped to 'none'.
1 parent 7d25ddc commit b50dc7a

File tree

2 files changed

+21
-340
lines changed

2 files changed

+21
-340
lines changed

‎lcidlc/src/InterfaceGenerate.cpp‎

Lines changed: 14 additions & 340 deletions
Original file line numberDiff line numberDiff line change
@@ -1295,358 +1295,28 @@ static bool InterfaceGenerateVariant(InterfaceRef self, CoderRef p_coder, Handle
12951295
delete[] t_mapped_params;
12961296
}
12971297

1298-
////////////////////////////////////////////////////////////////////////////////
1299-
1300-
static bool __InterfaceGenerateVariant(InterfaceRef self, CoderRef p_coder, Handler *p_handler, HandlerVariant *p_variant, HandlerMapping p_mapping)
1301-
{
1302-
Handler *t_handler;
1303-
t_handler = p_handler;
1304-
1305-
HandlerVariant *t_variant;
1306-
t_variant = p_variant;
1307-
1308-
CoderWriteLine(p_coder, "static bool variant__%s(MCVariableRef *argv, uint32_t argc, MCVariableRef result)", NameGetCString(t_variant -> binding));
1309-
CoderWriteLine(p_coder, "{");
1310-
if (self -> use_objc_objects)
1311-
{
1312-
CoderWriteLine(p_coder, "#ifdef __OBJC__");
1313-
CoderWriteLine(p_coder, "\tNSAutoreleasePool *t_pool;");
1314-
CoderWriteLine(p_coder, "\tt_pool = [[NSAutoreleasePool alloc] init];");
1315-
CoderWriteLine(p_coder, "#endif");
1316-
CoderWriteLine(p_coder, "");
1317-
}
1318-
1319-
CoderWriteLine(p_coder, "\tbool success;");
1320-
CoderWriteLine(p_coder, "\tsuccess = true;");
1321-
CoderWriteLine(p_coder, "");
1322-
1323-
bool t_need_newline;
1324-
t_need_newline = false;
1325-
for(uint32_t k = 0; k < t_variant -> parameter_count; k++)
1326-
{
1327-
HandlerParameter *t_parameter;
1328-
t_parameter = &t_variant -> parameters[k];
1329-
1330-
const char *t_name;
1331-
t_name = NameGetCString(t_parameter -> name);
1332-
1333-
NativeType t_native_type;
1334-
t_native_type = NativeTypeFromName(t_parameter -> type);
1335-
1336-
if (t_parameter -> mode == kParameterTypeInOut && (t_native_type == kNativeTypeCString || t_native_type == kNativeTypeCData))
1337-
{
1338-
CoderWriteLine(p_coder, "\t%s original__%s, %sparam__%s;", NativeTypeGetTypedef(t_native_type), t_name, NativeTypeGetSecondaryPrefix(t_native_type), t_name);
1339-
if (t_native_type != kNativeTypeCData)
1340-
CoderWriteLine(p_coder, "\toriginal__%s = param__%s = %s;", t_name, t_name, NativeTypeGetInitializer(t_native_type));
1341-
else
1342-
{
1343-
CoderWriteLine(p_coder, "\toriginal__%s . buffer = param__%s . buffer = nil;", t_name, t_name);
1344-
CoderWriteLine(p_coder, "\toriginal__%s . length = param__%s . length = 0;", t_name, t_name);
1345-
}
1346-
}
1347-
else
1348-
{
1349-
CoderWriteLine(p_coder, "\t%s param__%s;", NativeTypeGetTypedef(t_native_type), t_name);
1350-
if (t_native_type != kNativeTypeCData)
1351-
CoderWriteLine(p_coder, "\tparam__%s = %s;", t_name, NativeTypeGetInitializer(t_native_type));
1352-
else
1353-
{
1354-
CoderWriteLine(p_coder, "\tparam__%s . buffer = NULL;", t_name);
1355-
CoderWriteLine(p_coder, "\tparam__%s . length = 0;", t_name);
1356-
}
1357-
}
1358-
if (t_parameter -> mode == kParameterTypeInOut || t_parameter -> mode == kParameterTypeOut)
1359-
{
1360-
CoderWriteLine(p_coder, "\tif (success)", k);
1361-
CoderWriteLine(p_coder, "\t\tsuccess = verify__out_parameter(\"%s\", argv[%d]);", t_name, k);
1362-
}
1363-
if (t_parameter -> mode == kParameterTypeIn || t_parameter -> mode == kParameterTypeInOut)
1364-
{
1365-
CoderWriteLine(p_coder, "\tif (success)", k);
1366-
CoderWriteLine(p_coder, "\t{", k);
1367-
// MERG-2013-06-14: [[ ExternalsApiV5 ]] Changes to allow optional parameters without default value.
1368-
if (t_parameter -> is_optional)
1369-
{
1370-
CoderWriteLine(p_coder, "\t\tif (argc > %d)", k);
1371-
CoderWrite(p_coder, "\t\t\t");
1372-
if (t_native_type != kNativeTypeEnum)
1373-
CoderWriteLine(p_coder, "fetch__%s(\"%s\", argv[%d], param__%s);", NativeTypeGetTag(t_native_type), t_name, k, t_name);
1374-
else
1375-
CoderWriteLine(p_coder, "fetchenum__%s(\"%s\", argv[%d], param__%s);", name_to_cname(t_parameter -> type), t_name, k, t_name);
1376-
if (t_parameter -> default_value != nil)
1377-
{
1378-
CoderWriteLine(p_coder, "\t\telse", k);
1379-
switch(t_native_type)
1380-
{
1381-
case kNativeTypeBoolean:
1382-
CoderWriteLine(p_coder, "\t\t\tparam__%s = %s;", t_name, BooleanGetBool(t_parameter -> default_value) ? "true" : "false");
1383-
break;
1384-
case kNativeTypeCString:
1385-
CoderWriteLine(p_coder, "\t\t\tsuccess = default__%s(\"%s\", param__%s);", NativeTypeGetTag(t_native_type), StringGetCStringPtr(t_parameter -> default_value), t_name);
1386-
break;
1387-
case kNativeTypeObjcString:
1388-
CoderWriteLine(p_coder, "\t\t\tparam__%s = @\"%s\";", t_name, StringGetCStringPtr(t_parameter -> default_value));
1389-
break;
1390-
case kNativeTypeInteger:
1391-
CoderWriteLine(p_coder, "\t\t\tparam__%s = %lld;", t_name, NumberGetInteger(t_parameter -> default_value));
1392-
break;
1393-
case kNativeTypeReal:
1394-
CoderWriteLine(p_coder, "\t\t\tparam__%s = %.15g;", t_name, NumberGetReal(t_parameter -> default_value));
1395-
break;
1396-
case kNativeTypeEnum:
1397-
CoderWriteLine(p_coder, "\t\t\tparam__%s = %lld;", t_name, InterfaceResolveEnumElement(self, t_parameter -> type, t_parameter -> default_value));
1398-
break;
1399-
case kNativeTypeCData:
1400-
case kNativeTypeObjcData:
1401-
CoderWriteLine(p_coder, "\t\t\tsuccess = false;");
1402-
break;
1403-
default:
1404-
CoderWriteLine(p_coder, "\t\t\tsuccess = false;");
1405-
break;
1406-
}
1407-
}
1408-
}
1409-
else
1410-
{
1411-
if (t_native_type != kNativeTypeEnum)
1412-
CoderWriteLine(p_coder, "\t\tsuccess = fetch__%s(\"%s\", argv[%d], param__%s);", NativeTypeGetTag(t_native_type), t_name, k, t_name);
1413-
else
1414-
CoderWriteLine(p_coder, "\t\tsuccess = fetchenum__%s(\"%s\", argv[%d], param__%s);", name_to_cname(t_parameter -> type), t_name, k, t_name);
1415-
}
1416-
CoderWriteLine(p_coder, "\t}");
1417-
1418-
}
1419-
if ((t_native_type == kNativeTypeCString || t_native_type == kNativeTypeCData) && t_parameter -> mode == kParameterTypeInOut)
1420-
{
1421-
CoderWriteLine(p_coder, "\tif (success)");
1422-
CoderWriteLine(p_coder, "\t\toriginal__%s = param__%s", t_name, t_name);
1423-
}
1424-
1425-
t_need_newline = true;
1426-
}
1427-
if (t_need_newline)
1428-
CoderWriteLine(p_coder, "");
1429-
1430-
const char *t_ref_char;
1431-
if (self -> use_cpp_naming)
1432-
t_ref_char = "";
1433-
else
1434-
t_ref_char = "&";
1435-
1436-
NativeType t_native_return_type;
1437-
if (t_variant -> return_type != nil)
1438-
t_native_return_type = NativeTypeFromName(t_variant -> return_type);
1439-
else
1440-
t_native_return_type = kNativeTypeNone;
1441-
1442-
if (t_native_return_type != kNativeTypeNone)
1443-
{
1444-
CoderWriteLine(p_coder, "\t%s returnvalue;", NativeTypeGetTypedef(t_native_return_type));
1445-
if (t_native_return_type != kNativeTypeCData)
1446-
CoderWriteLine(p_coder, "\treturnvalue = %s;", NativeTypeGetInitializer(t_native_return_type));
1447-
else
1448-
{
1449-
CoderWriteLine(p_coder, "\treturnvalue . buffer = NULL;");
1450-
CoderWriteLine(p_coder, "\treturnvalue . length = 0;");
1451-
}
1452-
}
1453-
1454-
CoderWriteLine(p_coder, "\tif (success)");
1455-
CoderWriteLine(p_coder, "\t{");
1456-
CoderWriteLine(p_coder, "\t\terror__clear();");
1457-
1458-
if (self -> use_cpp_exceptions)
1459-
{
1460-
CoderWriteLine(p_coder, "\t\ttry");
1461-
CoderWriteLine(p_coder, "\t\t{");
1462-
}
1463-
1464-
if (self -> use_objc_exceptions)
1465-
{
1466-
CoderWriteLine(p_coder, "#ifdef __OBJC__");
1467-
CoderWriteLine(p_coder, "\tNS_DURING");
1468-
CoderWriteLine(p_coder, "#endif");
1469-
}
1470-
1471-
if (t_native_return_type != kNativeTypeNone)
1472-
{
1473-
if (!t_variant -> return_type_indirect)
1474-
CoderWrite(p_coder, "\t\treturnvalue = %s(", NameGetCString(t_variant -> binding));
1475-
else
1476-
CoderWrite(p_coder, "\t\t%s(%sreturnvalue", NameGetCString(t_variant -> binding), t_ref_char);
1477-
}
1478-
else
1479-
CoderWrite(p_coder, "\t\t%s(", NameGetCString(t_variant -> binding));
1480-
1481-
for(uint32_t k = 0; k < t_variant -> parameter_count; k++)
1482-
{
1483-
HandlerParameter *t_parameter;
1484-
t_parameter = &t_variant -> parameters[k];
1485-
1486-
if (k > 0 || t_variant -> return_type_indirect)
1487-
CoderWrite(p_coder, ", ");
1488-
CoderWrite(p_coder, "%sparam__%s", t_parameter -> mode == kParameterTypeInOut || t_parameter -> mode == kParameterTypeOut ? t_ref_char : "", NameGetCString(t_parameter -> name));
1489-
}
1490-
1491-
CoderWrite(p_coder, ");\n");
1492-
CoderWriteLine(p_coder, "\t\tsuccess = error__catch();");
1493-
1494-
if (self -> use_objc_exceptions)
1495-
{
1496-
CoderWriteLine(p_coder, "#ifdef __OBJC__");
1497-
CoderWriteLine(p_coder, "\t\tNS_HANDLER");
1498-
CoderWriteLine(p_coder, "\t\t\tsuccess = error__raise([[localException reason] cStringUsingEncoding: NSMacOSRomanStringEncoding]);");
1499-
CoderWriteLine(p_coder, "\t\tNS_ENDHANDLER");
1500-
CoderWriteLine(p_coder, "#endif");
1501-
}
1502-
1503-
if (self -> use_cpp_exceptions)
1504-
{
1505-
CoderWriteLine(p_coder, "\t\t}");
1506-
CoderWriteLine(p_coder, "\t\tcatch(std::exception& t_exception)");
1507-
CoderWriteLine(p_coder, "\t\t{");
1508-
CoderWriteLine(p_coder, "\t\t\tsuccess = error__raise(t_exception . what());");
1509-
CoderWriteLine(p_coder, "\t\t}");
1510-
CoderWriteLine(p_coder, "\t\tcatch(...)");
1511-
CoderWriteLine(p_coder, "\t\t{");
1512-
CoderWriteLine(p_coder, "\t\t\tsuccess = error__unknown();");
1513-
CoderWriteLine(p_coder, "\t\t}");
1514-
}
1515-
1516-
CoderWriteLine(p_coder, "\t}");
1517-
1518-
if (t_native_return_type != kNativeTypeNone)
1519-
{
1520-
CoderWriteLine(p_coder, "\tif (success)");
1521-
if (t_native_return_type != kNativeTypeEnum)
1522-
CoderWriteLine(p_coder, "\t\tsuccess = store__%s(result, returnvalue);", NativeTypeGetTag(t_native_return_type));
1523-
else
1524-
CoderWriteLine(p_coder, "\t\tsuccess = storeenum__%s(result, returnvalue);", name_to_cname(t_variant -> return_type));
1525-
}
1526-
CoderWriteLine(p_coder, "");
1527-
1528-
t_need_newline = false;
1529-
for(uint32_t k = t_variant -> parameter_count; k > 0; k--)
1530-
{
1531-
HandlerParameter *t_parameter;
1532-
t_parameter = &t_variant -> parameters[k - 1];
1533-
if (t_parameter -> mode == kParameterTypeIn)
1534-
continue;
1535-
1536-
const char *t_name;
1537-
t_name = NameGetCString(t_parameter -> name);
1538-
1539-
NativeType t_native_type;
1540-
t_native_type = NativeTypeFromName(t_parameter -> type);
1541-
1542-
CoderWriteLine(p_coder, "\tif (success)");
1543-
if (t_native_type != kNativeTypeEnum)
1544-
CoderWriteLine(p_coder, "\t\tsuccess = store__%s(argv[%d], param__%s);", NativeTypeGetTag(t_native_type), k - 1, t_name);
1545-
else
1546-
CoderWriteLine(p_coder, "\t\tsuccess = storeenum__%s(argv[%d], param__%s);", name_to_cname(t_parameter -> type), k - 1, t_name);
1547-
1548-
t_need_newline = true;
1549-
}
1550-
if (t_need_newline)
1551-
CoderWriteLine(p_coder, "");
1552-
1553-
CoderWriteLine(p_coder, "\tif (!success)");
1554-
CoderWriteLine(p_coder, "\t\tsuccess = error__report(result);");
1555-
CoderWriteLine(p_coder, "");
1556-
1557-
t_need_newline = false;
1558-
if (t_native_return_type == kNativeTypeCString)
1559-
{
1560-
CoderWriteLine(p_coder, "\tfree(returnvalue);");
1561-
t_need_newline = true;
1562-
}
1563-
else if (t_native_return_type == kNativeTypeCData)
1564-
{
1565-
CoderWriteLine(p_coder, "\tfree(returnvalue . buffer);");
1566-
t_need_newline = true;
1567-
}
1568-
for(uint32_t k = t_variant -> parameter_count; k > 0; k--)
1569-
{
1570-
HandlerParameter *t_parameter;
1571-
t_parameter = &t_variant -> parameters[k - 1];
1572-
1573-
const char *t_name;
1574-
t_name = NameGetCString(t_parameter -> name);
1575-
1576-
NativeType t_native_type;
1577-
t_native_type = NativeTypeFromName(t_parameter -> type);
1578-
1579-
if (t_native_type == kNativeTypeCString)
1580-
{
1581-
CoderWriteLine(p_coder, "\tfree(param__%s);", t_name);
1582-
if (t_parameter -> mode == kParameterTypeInOut)
1583-
{
1584-
CoderWriteLine(p_coder, "\tif (param__%s != original__%s)", t_name, t_name);
1585-
CoderWriteLine(p_coder, "\t\tfree(original__%s);", t_name);
1586-
}
1587-
1588-
t_need_newline = true;
1589-
}
1590-
else if (t_native_type == kNativeTypeCData)
1591-
{
1592-
CoderWriteLine(p_coder, "\tfree(param__%s . buffer);", t_name);
1593-
if (t_parameter -> mode == kParameterTypeInOut)
1594-
{
1595-
CoderWriteLine(p_coder, "\tif (param__%s . buffer != original__%s . buffer)", t_name, t_name);
1596-
CoderWriteLine(p_coder, "\t\tfree(original__%s . buffer);", t_name);
1597-
}
1598-
1599-
t_need_newline = true;
1600-
}
1601-
1602-
}
1603-
if (t_need_newline)
1604-
CoderWriteLine(p_coder, "");
1605-
1606-
if (self -> use_objc_objects)
1607-
{
1608-
CoderWriteLine(p_coder, "#ifdef __OBJC__");
1609-
CoderWriteLine(p_coder, "\t[t_pool release];");
1610-
CoderWriteLine(p_coder, "#endif");
1611-
CoderWriteLine(p_coder, "");
1612-
}
1613-
1614-
CoderWriteLine(p_coder, "\treturn success;");
1615-
1616-
CoderWriteLine(p_coder, "}");
1617-
1618-
/*if (p_mapping == kHandlerMappingJava)
1619-
{
1620-
for(uint32_t i = 0; i < t_handler -> variant_count; i++)
1621-
InterfaceGenerateJavaHandlerStub(self, p_coder, t_handler, &t_handler -> variants[i]);
1622-
}*/
1298+
static void InterfaceGenerateUnsupportedVariant(InterfaceRef self, CoderRef p_coder, Handler *p_handler, HandlerVariant *p_variant, HandlerMapping p_mapping)
1299+
{
1300+
CoderBegin(p_coder, "static bool variant__%s(MCVariableRef *argv, uint32_t argc, MCVariableRef result)", NameGetCString(t_variant -> binding));
1301+
CoderWriteStatement(p_coder, "return error__report_not_supported(result)");
1302+
CoderEnd(p_coder, "");
16231303
}
16241304

1305+
////////////////////////////////////////////////////////////////////////////////
1306+
16251307
static bool InterfaceGenerateHandlers(InterfaceRef self, CoderRef p_coder)
16261308
{
16271309
for(uint32_t i = 0; i < self -> handler_count; i++)
16281310
{
16291311
Handler *t_handler;
16301312
t_handler = &self -> handlers[i];
1631-
1632-
/* if (t_handler -> type == kHandlerTypeMethod)
1633-
{
1634-
// Generate stub for calling Java or native method.
1635-
if (t_handler -> is_java)
1636-
InterfaceGenerateJavaMethodStub(self, p_coder, t_handler);
1637-
#ifdef NOT_READY
1638-
else
1639-
InterfaceGenerateNativeMethodStub(self, p_coder, t_handler);
1640-
#endif
1641-
continue;
1642-
}*/
1643-
1313+
16441314
for(uint32_t j = 0; j < t_handler -> variant_count; j++)
16451315
{
16461316
HandlerVariant *t_variant;
16471317
t_variant = &t_handler -> variants[j];
16481318

1649-
for(HandlerMapping t_mapping = kHandlerMappingC; t_mapping <= kHandlerMappingJava; t_mapping++)
1319+
for(HandlerMapping t_mapping = kHandlerMappingNone; t_mapping <= kHandlerMappingJava; t_mapping++)
16501320
{
16511321
// Find all platforms requiring the current mapping type.
16521322
uint32_t t_platforms;
@@ -1671,8 +1341,12 @@ static bool InterfaceGenerateHandlers(InterfaceRef self, CoderRef p_coder)
16711341
MCCStringAppendFormat(t_defineds, "defined(%s)", s_platform_macros[t_platform]);
16721342
}
16731343

1344+
// Generate the variant
16741345
CoderBeginPreprocessor(p_coder, "#if %s", t_defineds);
1675-
InterfaceGenerateVariant(self, p_coder, t_handler, t_variant, t_mapping);
1346+
if (t_mapping != kHandlerMappingNone)
1347+
InterfaceGenerateVariant(self, p_coder, t_handler, t_variant, t_mapping);
1348+
else
1349+
InterfaceGenerateUnsupportedVariant(self, p_coder, t_handler, t_variant);
16761350
CoderEndPreprocessor(p_coder, "#endif");
16771351

16781352
MCCStringFree(t_defineds);

‎lcidlc/src/Support.mm‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2514,6 +2514,13 @@ static bool error__report_bad_parameter_count(MCVariableRef result)
25142514
return false;
25152515
}
25162516

2517+
static bool error__report_not_supported(MCVariantRef result)
2518+
{
2519+
const char *msg = "not supported";
2520+
MCVariableStore(result, kMCOptionAsCString, &msg);
2521+
return false;
2522+
}
2523+
25172524
////////////////////////////////////////////////////////////////////////////////
25182525

25192526
static bool default__cstring(const char *arg, char*& r_value)

0 commit comments

Comments
 (0)