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; }