SgType * TypeTable::createType(const std::string & name) {
if(boost::starts_with(name, "complex ")) {
std::string subtype = name.substr(8, std::string::npos);
return SageBuilder::buildComplexType(createType(nameToType(subtype)));
}
return createType(nameToType(name));
}
// called on first fetch
void QSQLite2ResultPrivate::init(const char **cnames, int numCols)
{
if (!cnames)
return;
rInf.clear();
if (numCols <= 0)
return;
q->init(numCols);
for (int i = 0; i < numCols; ++i) {
const char* lastDot = strrchr(cnames[i], '.');
const char* fieldName = lastDot ? lastDot + 1 : cnames[i];
//remove quotations around the field name if any
QString fieldStr = QString::fromAscii(fieldName);
QLatin1Char quote('\"');
if ( fieldStr.length() > 2 && fieldStr.startsWith(quote) && fieldStr.endsWith(quote)) {
fieldStr = fieldStr.mid(1);
fieldStr.chop(1);
}
rInf.append(QSqlField(fieldStr,
nameToType(QString::fromAscii(cnames[i+numCols]))));
}
}
Properties VariantToMapConverter::toProperties(const QVariant &propertiesVariant,
const QVariant &propertyTypesVariant) const
{
const QVariantMap propertiesMap = propertiesVariant.toMap();
const QVariantMap propertyTypesMap = propertyTypesVariant.toMap();
Properties properties;
QVariantMap::const_iterator it = propertiesMap.constBegin();
QVariantMap::const_iterator it_end = propertiesMap.constEnd();
for (; it != it_end; ++it) {
int type = nameToType(propertyTypesMap.value(it.key()).toString());
if (type == QVariant::Invalid)
type = QVariant::String;
QVariant value = it.value();
if (type == filePathTypeId())
value = resolvePath(mMapDir, value);
value = fromExportValue(value, type);
properties[it.key()] = value;
}
return properties;
}
static status
updatePopupGesture(PopupGesture g, EventObj ev)
{ PopupObj p;
Any rec = getMasterEvent(ev);
DEBUG(NAME_popup, Cprintf("updatePopupGesture(): rec=%s\n", pp(rec)));
if ( notNil(g->popup) )
{ if ( instanceOfObject(g->popup, ClassFunction) )
{ TRY( p = getForwardReceiverFunction((Function) g->popup, rec,
rec, ev, EAV) );
TRY( p = checkType(p, nameToType(NAME_popup), g));
} else
p = g->popup;
} else
{ if ( !(p = get(rec, NAME_popup, EAV)) ||
!instanceOfObject(p, ClassPopup) )
fail;
}
assign(g, current, p);
if ( isNil(g->context) )
assign(g, context, notNil(p->context) ? p->context : rec);
send(p, NAME_update, g->context, EAV);
if ( p->active == OFF || emptyChain(p->members) )
{ send(g, NAME_cancel, ev, EAV);
fail;
}
succeed;
}
int
ws_provide_selection(int format)
{ DisplayObj d = CurrentDisplay(NIL);
Hyper h;
Function msg;
Name which = NAME_primary;
Name hypername = getAppendName(which, NAME_selectionOwner);
Name type;
if ( d && notNil(d) &&
(h = getFindHyperObject(d, hypername, DEFAULT)) &&
(type = getAttributeObject(h, NAME_type)) &&
(msg = getAttributeObject(h, NAME_convertFunction)) &&
(msg = checkType(msg, TypeFunction, NIL)) )
{ Any val;
DEBUG(NAME_selection, Cprintf("Provide %s selection of type %s\n",
pp(which), pp(type)));
if ( !(val = getForwardReceiverFunction(msg, h->to, which, type, EAV)) )
return FALSE;
DEBUG(NAME_selection, Cprintf("Got %s\n", pp(val)));
if ( type == NAME_text )
{ CharArray ca = checkType(val, TypeCharArray, NIL);
if ( ca )
{ String s = &ca->data;
HGLOBAL mem = ws_string_to_global_mem(s);
if ( mem )
SetClipboardData(CF_UNICODETEXT, mem);
return TRUE;
}
} else if ( type == NAME_emf || type == NAME_wmf )
{ Any mf = checkType(val, nameToType(NAME_winMetafile), NIL);
if ( mf )
{ DEBUG(NAME_selection, Cprintf("Providing win_metafile\n"));
return ws_on_clipboard_metafile(mf, type);
}
} else
return errorPce(d, NAME_noSelectionType, type);
}
return FALSE;
}
// called on first fetch
void QSQLiteResultPrivate::init(const char **cnames, int numCols, QtSqlCachedResult::RowCache **row)
{
if (!cnames)
return;
rInf.clear();
if (numCols <= 0)
return;
for (int i = 0; i < numCols; ++i) {
const char* lastDot = strrchr(cnames[i], '.');
const char* fieldName = lastDot ? lastDot + 1 : cnames[i];
rInf.append(QSqlFieldInfo(fieldName, nameToType(cnames[i+numCols])));
}
// skip the first fetch
if (row && !*row) {
*row = new QtSqlCachedResult::RowCache(numCols);
skipRow = *row;
}
}
Prerequisite::Prerequisite(const QDomElement & elem)
{
_dependency = 0;
_message = QString::null;
_name = elem.attribute("name");
_query = QString::null;
_type = nameToType(elem.attribute("type"));
QDomNodeList nList = elem.childNodes();
for(int n = 0; n < nList.count(); ++n)
{
QDomElement elemThis = nList.item(n).toElement();
if(elemThis.tagName() == "query")
_query = elemThis.text();
else if(elemThis.tagName() == "message")
_message = elemThis.text();
else if(elemThis.tagName() == "providedby")
{
PrerequisiteProvider provider(elemThis);
if(provider.isValid())
_providers.append(provider);
}
else if (elemThis.tagName() == "dependson")
_dependency = new DependsOn(elemThis.attribute("name"),
elemThis.attribute("version"),
elemThis.attribute("developer"));
else
{
// ERROR?
}
}
if (DEBUG)
qDebug("Prerequisite(QDomElement&): name %s, type %d (%s), message %s, "
"dependency %p (%s %s %s), query %s",
qPrintable(_name), _type, qPrintable(typeToName(_type)),
qPrintable(_message), _dependency,
qPrintable(_dependency ? _dependency->name() : QString()),
qPrintable(_dependency ? _dependency->version() : QString()),
qPrintable(_dependency ? _dependency->developer(): QString()),
qPrintable(_query));
}
FunctionNode* Parser::parseFunction() {
uint32_t tokenIndex = _currentTokenIndex;
ensureKeyword("function");
if (currentToken() != tIDENT) {
error("identifier expected");
}
const string& returnTypeName = currentTokenValue();
VarType returnType = nameToType(returnTypeName);
if (returnType == VT_INVALID) {
error("wrong return type");
}
consumeToken();
if (currentToken() != tIDENT) {
error("name expected");
}
const string& name = currentTokenValue();
consumeToken();
Signature signature;
signature.push_back(SignatureElement(returnType, "return"));
ensureToken(tLPAREN);
while (currentToken() != tRPAREN) {
const string& parameterTypeName = currentTokenValue();
VarType parameterType = nameToType(parameterTypeName);
if (parameterType == VT_INVALID) {
error("wrong parameter type");
}
consumeToken();
const string& parameterName = currentTokenValue();
if (currentToken() != tIDENT) {
error("identifier expected");
}
consumeToken();
signature.push_back(SignatureElement(parameterType, parameterName));
if (currentToken() == tCOMMA) {
consumeToken();
}
}
ensureToken(tRPAREN);
BlockNode* body = 0;
pushScope();
for (uint32_t i = 1; i < signature.size(); i++) {
const string& name = signature[i].second;
VarType type = signature[i].first;
if (!_currentScope->declareVariable(name, type)) {
error("Formal \"%s\" already declared", name.c_str());
}
}
if ((currentToken() == tIDENT) && currentTokenValue() == "native") {
consumeToken();
if (currentToken() != tSTRING) {
error("Native name expected, got %s", tokenStr(currentToken()));
}
pushScope();
body = new BlockNode(_currentTokenIndex, _currentScope);
body->add(new NativeCallNode(tokenIndex, currentTokenValue(), signature));
consumeToken();
ensureToken(tSEMICOLON);
body->add(new ReturnNode(0, 0));
popScope();
} else {
body = parseBlock(true, false);
if (body->nodes() == 0 ||
!(body->nodeAt(body->nodes() - 1)->isReturnNode())) {
body->add(new ReturnNode(0, defaultReturnExpr(returnType)));
}
}
popScope();
if (_currentScope->lookupFunction(name) != 0) {
error("Function %s already defined", name.c_str());
}
FunctionNode* result = new FunctionNode(tokenIndex, name, signature, body);
_currentScope->declareFunction(result);
// We don't add function node into AST.
return 0;
}