bool endElement(const QString &namespaceURI,
const QString &localName,
const QString &qName)
{
// Clean up elements stack:
// Since we made sure to get the elements in the proper order when
// adding we do not need to do so again here.
COND_DOC_ERROR(m_elementStack.last()->element != qName.utf8(),
QString("Malformed XML: Unexpected closing element found.").
arg(m_elementStack.last()->element).utf8());
m_elementStack.removeLast();
// Interface:
if (DBUS("interface"))
{
CONDITION(!m_currentInterface, "end of interface found without start.");
m_currentInterface->endBodyLine = lineNumber();
closeScopes();
m_currentInterface = 0;
}
if (DBUS("method") || DBUS("signal"))
{
CONDITION(!m_currentMethod, "end of method found without start.");
CONDITION(!m_currentInterface, "end of method found outside interface.");
m_currentMethod->endBodyLine = lineNumber();
m_currentInterface->addSubEntry(m_currentMethod);
m_currentMethod = 0;
}
if (DBUS("property"))
{
CONDITION(!m_currentProperty, "end of property found without start.");
CONDITION(!m_currentInterface, "end of property found outside interface.");
m_currentProperty->endBodyLine = lineNumber();
m_currentInterface->addSubEntry(m_currentProperty);
m_currentProperty = 0;
}
if (DBUS("arg"))
{
CONDITION(!m_currentMethod, "end of arg found outside method.");
m_currentMethod->argList->append(m_currentArgument);
m_currentArgument = 0;
}
if (EXTENSION("namespace"))
{
Entry * current = m_namespaceStack.last();
CONDITION(!current, "end of namespace without start.");
m_namespaceStack.removeLast();
current->endBodyLine = lineNumber();
closeScopes();
}
if (EXTENSION("struct"))
{
StructData * data = m_structStack.last();
CONDITION(!data, "end of struct without start.");
data->entry->endBodyLine = lineNumber();
QString current_type;
current_type.append(QString("("));
current_type.append(data->type);
current_type.append(QString(")"));
addNamedType(current_type.utf8());
closeScopes();
m_structStack.removeLast();
}
if (EXTENSION("member"))
{
StructData * data = m_structStack.last();
CONDITION(!data, "end of member outside struct.");
data->entry->addSubEntry(m_currentEntry);
}
if (EXTENSION("enum") || EXTENSION("flagset"))
{
CONDITION(!m_currentEnum, "end of enum without start.");
m_currentEnum->endBodyLine = lineNumber();
closeScopes();
m_currentEnum = 0;
}
if (EXTENSION("value"))
{
CONDITION(!m_currentEntry, "end of value without start");
m_currentEntry->endBodyLine = lineNumber();
m_currentEnum->addSubEntry(m_currentEntry);
}
return true;
}
/*--------------------------------------------------------------------------*/
int C2F(inittypenames)()
{
int ierr = 0;
int i = 0;
/* initialize COMMON (struct) */
C2F(typnams).ptmax = 1;
for (i = 0; i < MAX_SCILAB_DEFINED_TYPE; i++)
{
C2F(typnams).tp[i] = i;
C2F(typnams).ln[i] = 0;
C2F(typnams).ptr[i] = 0;
}
/* add types */
ierr = addNamedType("s", sci_matrix);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("p", sci_poly);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("b", sci_boolean);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("sp", sci_sparse);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("spb", sci_boolean_sparse);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("msp", sci_matlab_sparse);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("i", sci_ints);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("h", sci_handles);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("c", sci_strings);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("m", sci_u_function);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("mc", sci_c_function);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("f", sci_lib);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("l", sci_list);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("tl", sci_tlist);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("ml", sci_mlist);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("ptr", sci_lufact_pointer);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("ip", sci_implicit_poly);
if (ierr)
{
callError(ierr);
return 1;
}
ierr = addNamedType("fptr", sci_intrinsic_function);
if (ierr)
{
callError(ierr);
return 1;
}
return 0;
}
bool startElement(const QString &namespaceURI,
const QString &localName,
const QString &qName,
const QXmlAttributes &attributes)
{
// add to elements stack:
m_elementStack.append(new ElementData(qName.utf8()));
// First we need a node.
if (DBUS("node"))
{
CONDITION(!m_currentNode.isEmpty(), "Node inside a node.");
const int idx(indexOf(attributes, "name"));
COND_DOC_ERROR(idx < 0, QCString("Anonymous node found."));
m_currentNode = attributes.value(idx).utf8();
// A node is actually of little interest, so do nothing here.
return true;
}
// Then we need an interface.
if (DBUS("interface"))
{
// We need a nodeName for interfaces:
CONDITION(m_currentNode.isEmpty(), "Interface without a node.");
CONDITION(m_currentInterface, "Interface within another interface.");
const int idx(indexOf(attributes, "name"));
COND_DOC_ERROR(idx < 0, QString("Interface without a name found."));
// A interface is roughly equivalent to a class:
m_currentInterface = createEntry();
m_currentInterface->section = Entry::CLASS_SEC;
m_currentInterface->spec |= Entry::Interface;
m_currentInterface->type = "Interface";
m_currentInterface->name = substitute(attributes.value(idx).utf8(), ".", "::");
openScopes(m_currentInterface);
return true;
}
if (DBUS("method") || DBUS("signal"))
{
// We need a interfaceName for methods and signals:
CONDITION(!m_currentInterface, "Method or signal found outside a interface.");
CONDITION(m_currentMethod, "Method or signal found inside another method or signal.");
CONDITION(m_currentProperty, "Methor or signal found inside a property.");
CONDITION(!m_structStack.isEmpty(), "Method or signal found inside a struct.");
CONDITION(m_currentEnum, "Methor or signal found inside a enum.");
const int idx(indexOf(attributes, "name"));
COND_DOC_ERROR(idx < 0, QString("Method or signal without a name found."));
m_currentMethod = createEntry();
m_currentMethod->section = Entry::FUNCTION_SEC;
m_currentMethod->name = attributes.value(idx).utf8();
m_currentMethod->mtype = Method;
m_currentMethod->type = "void";
if (DBUS("signal"))
{ m_currentMethod->mtype = Signal; }
}
if (DBUS("arg"))
{
// We need a method for arguments:
CONDITION(!m_currentMethod, "Argument found outside a method or signal.");
CONDITION(m_currentArgument, "Argument found inside another argument.");
const int name_idx(indexOf(attributes, "name"));
COND_DOC_ERROR(name_idx < 0, QString("Argument without a name found."));
COND_DOC_ERROR(!hasType(attributes), QString("Argument without a type found."));
const int direction_idx(indexOf(attributes, "direction"));
if ((m_currentMethod->mtype == Signal &&
direction_idx >= 0 &&
attributes.value(direction_idx) != "in") ||
(m_currentMethod->mtype == Method &&
direction_idx >= 0 &&
attributes.value(direction_idx) != "in" &&
attributes.value(direction_idx) != "out"))
{
m_errorString = "Invalid direction found.";
return false;
}
m_currentArgument = new Argument;
m_currentArgument->type = getType(attributes).utf8();
m_currentArgument->name = attributes.value(name_idx).utf8();
if (direction_idx >= 0)
{ m_currentArgument->attrib = attributes.value(direction_idx).utf8(); }
else
{
if (m_currentMethod->mtype == Signal)
{ m_currentArgument->attrib = "in"; }
else
{ m_currentArgument->attrib = "out"; }
}
}
if (DBUS("property"))
{
CONDITION(m_currentMethod, "Property found inside a method or signal.");
CONDITION(!m_currentInterface, "Property found outside an interface.");
CONDITION(m_currentProperty, "Property found inside another property.");
CONDITION(!m_structStack.isEmpty(), "Property found inside a struct.");
CONDITION(m_currentEnum, "Property found inside a enum.");
const int name_idx(indexOf(attributes, "name"));
COND_DOC_ERROR(name_idx < 0, QString("Anonymous property found."));
COND_DOC_ERROR(!hasType(attributes), QString("Property without a type found."));
const int access_idx(indexOf(attributes, "access"));
COND_DOC_ERROR(access_idx < 0, QString("Property without a access attribute found."));
COND_DOC_ERROR(attributes.value(access_idx) != "read" &&
attributes.value(access_idx) != "write" &&
attributes.value(access_idx) != "readwrite",
QString("Property with invalid access attribute \"%1\" found.").
arg(attributes.value(access_idx)));
m_currentProperty = createEntry();
m_currentProperty->section = Entry::FUNCTION_SEC;
if (attributes.value(access_idx) == "read" ||
attributes.value(access_idx) == "readwrite")
{ m_currentProperty->spec |= Entry::Readable; }
if (attributes.value(access_idx) == "write" ||
attributes.value(access_idx) == "readwrite")
{ m_currentProperty->spec |= Entry::Writable; }
m_currentProperty->name = attributes.value(name_idx).utf8();
m_currentProperty->mtype = Property;
m_currentProperty->type = getType(attributes).utf8();
}
if (EXTENSION("namespace"))
{
CONDITION(m_currentNode.isEmpty(), "Namespace found outside a node.");
CONDITION(m_currentInterface, "Namespace found inside an interface.");
const int idx(indexOf(attributes, "name"));
COND_DOC_ERROR(idx < 0, QString("Anonymous namespace found."));
m_namespaceStack.append(openNamespace(attributes.value(idx)));
openScopes(m_namespaceStack.last());
}
if (EXTENSION("struct"))
{
CONDITION(m_currentMethod, "Struct found inside a method or signal.");
CONDITION(m_currentProperty, "Struct found inside a property.");
CONDITION(m_currentEnum, "Struct found inside an enum.");
const int idx(indexOf(attributes, "name"));
COND_DOC_ERROR(idx < 0, QString("Anonymous struct found."));
Entry * current_struct = createEntry();
current_struct->section = Entry::CLASS_SEC;
current_struct->spec = Entry::Struct;
current_struct->name = attributes.value(idx).utf8();
openScopes(current_struct);
current_struct->type = current_struct->name + " struct";
m_structStack.append(new StructData(current_struct));
}
if (EXTENSION("member"))
{
CONDITION(m_structStack.isEmpty(), "Member found outside of struct.");
const int name_idx(indexOf(attributes, "name"));
COND_DOC_ERROR(name_idx < 0, QString("Anonymous member found."));
COND_DOC_ERROR(!hasType(attributes), QString("Member without a type found."));
createEntry();
m_currentEntry->section = Entry::VARIABLE_SEC;
m_currentEntry->name = attributes.value(name_idx).utf8();
m_currentEntry->type = getType(attributes).utf8();
QString type(getDBusType(m_currentEntry->type));
m_structStack.last()->type.append(type.utf8());
}
if (EXTENSION("enum") || EXTENSION("flagset"))
{
CONDITION(m_currentMethod, "Enum found inside a method or signal.");
CONDITION(m_currentProperty, "Enum found inside a property.");
const int name_idx(indexOf(attributes, "name"));
COND_DOC_ERROR(name_idx < 0, QString("Anonymous enum found."));
const int type_idx(indexOf(attributes, "type"));
QString type = "u";
if (type_idx >= 0)
{ type = attributes.value(type_idx); }
if (type != "y" && type != "q" && type != "u" && type != "t")
{ DOC_ERROR(QString("Invalid enum type \"%1\" found.").arg(type)); }
m_currentEnum = createEntry();
m_currentEnum->section = Entry::ENUM_SEC;
m_currentEnum->name = attributes.value(name_idx).utf8();
openScopes(m_currentEnum);
m_currentEnum->type = m_currentEntry->name + " enum";
addNamedType(type.utf8());
}
if (EXTENSION("value"))
{
CONDITION(!m_currentEnum, "Value found outside an enum.");
const int name_idx(indexOf(attributes, "name"));
COND_DOC_ERROR(name_idx < 0, QString("Anonymous value found."));
const int value_idx(indexOf(attributes, "value"));
createEntry();
m_currentEntry->section = Entry::VARIABLE_SEC;
m_currentEntry->name = attributes.value(name_idx).utf8();
m_currentEntry->type = m_currentEnum->name; // "@"; // enum marker!
if (value_idx >= 0)
{ m_currentEntry->initializer = attributes.value(value_idx).utf8(); }
}
return true;
}
/*--------------------------------------------------------------------------*/
int sci_typename_two_rhs(char *fname, unsigned long fname_len)
{
SciErr sciErr;
int m1 = 0, n1 = 0;
int iType1 = 0;
int *piAddressVarOne = NULL;
char *pStVarOne = NULL;
int lenStVarOne = 0;
int m2 = 0, n2 = 0;
int iType2 = 0;
int *piAddressVarTwo = NULL;
double *pdVarTwo = NULL;
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarOne, &iType1);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddressVarTwo, &iType2);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if ( iType1 != sci_strings )
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
if ( iType2 != sci_matrix )
{
Scierror(999, _("%s: Wrong type for input argument #%d: A scalar expected.\n"), fname, 2);
return 0;
}
sciErr = getMatrixOfDouble(pvApiCtx, piAddressVarTwo, &m2, &n2, &pdVarTwo);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
return 0;
}
if ( (m2 != n2) && (n2 != 1) )
{
Scierror(999, _("%s: Wrong size for input argument #%d: A scalar expected.\n"), fname, 2);
return 0;
}
sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if ( (m1 != n1) && (n1 != 1) )
{
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 0;
}
pStVarOne = (char*)MALLOC(sizeof(char) * (lenStVarOne + 1));
sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
if (pStVarOne)
{
int ierr = 0;
sciErr = getMatrixOfString(pvApiCtx, piAddressVarOne, &m1, &n1, &lenStVarOne, &pStVarOne);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
return 0;
}
ierr = addNamedType(pStVarOne, (int)pdVarTwo[0]);
switch (ierr)
{
case -1 :
Scierror(999, _("%s: '%s' already exists.\n"), fname, pStVarOne);
break;
case 0:
LhsVar(1) = 0;
PutLhsVar();
break;
break;
case 1:
case 3:
SciError(224);
break;
case 2:
SciError(225);
break;
default:
/* never here */
Scierror(999, _("%s: Unknown Error.\n"), fname);
break;
}
FREE(pStVarOne);
pStVarOne = NULL;
}
else
{
Scierror(999, _("%s: No more memory.\n"), fname);
}
return 0;
}
