void ClassDiagramView::displayAddClassDialog()
{
AddClassDialog dialog;
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node && node->getType())
{
OovString title = "Add Class ";
title += node->getType()->getName();
dialog.setTitle(title);
}
// Fill the dialog with the default radio button and selected class info.
GtkWidget *radio = Builder::getBuilder()->getWidget("AddClassStandardRadiobutton");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), true);
GtkWidget *relayout = Builder::getBuilder()->getWidget("AddClassRelayoutCheckbutton");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(relayout), false);
// Even though the toggle was set above, it doesn't trigger unless it has changed.
on_AddClassStandardRadiobutton_toggled(radio, nullptr);
if(dialog.run(true))
{
getDiagram().addRelatedNodesRecurse(getDiagram().getModelData(),
dialog.getSelectedType(), dialog.getSelectedAddType());
updateGraph(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(relayout)));
}
}
/**
* Checks for invalid methods (e.g., overloading vs. overriding)
*/
void typecheck::CheckScope::checkMethods(ClassNode* cls) {
string* superName = cls->getSuper();
if(superName == nullptr) {
return;
}
Groot* groot = cls->getLexParent();
/* For every method defined in this class... */
for(auto method_kv : cls->getMethods()) {
string methodSig = getMethodSig(cls, string(method_kv.first));
/* Step up the inheritance tree, checking for another method with the same signature */
while(superName != nullptr) {
ClassNode* superClass = groot->getClasses()[*superName]; // Get the node for the symbol class. Note that cls->getLexParent() returns Groot.
superName = superClass->getSuper();
/* If this super doesn't have a method by the correct name, don't bother checking the signatures */
if(superClass->getMethods().find(method_kv.first) == superClass->getMethods().end()) {
continue;
}
if(methodSig != getMethodSig(superClass, method_kv.first)) {
std::stringstream msg;
msg << "Error: Method '" << method_kv.first << "' has a different signature from the super class";
throw ScopeCheckErr(msg.str().c_str());
}
}
}
}
void QsCodeParser::parseHeaderFile(const Location& location,
const QString& filePath,
Tree *tree)
{
qsTre = tree;
FILE *in = fopen(QFile::encodeName(filePath), "r");
if (in == 0) {
location.error(tr("Cannot open Qt Script class list '%1'")
.arg(filePath));
return;
}
Location fileLocation(filePath);
Tokenizer fileTokenizer(fileLocation, in);
int tok = fileTokenizer.getToken();
while (tok != Tok_Eoi) {
if (tok == Tok_Ident) {
ClassNode *quickClass = new ClassNode(qsTre->root(),
fileTokenizer.lexeme());
quickClass->setLocation(fileTokenizer.location());
}
else {
fileTokenizer.location().error(tr("Unexpected token '%1' in Qt"
" Script class list")
.arg(fileTokenizer.lexeme()));
break;
}
tok = fileTokenizer.getToken();
}
fclose(in);
}
/**
* Defines the requirements for a valid class scope
* Throws a ScopeCheckErr exception if there's a problem.
*/
void typecheck::CheckScope::checkClass(typecheck::ClassNode* cls) {
string* superName = cls->getSuper();
if(superName == nullptr) {
return;
}
/* Register the super class if it exists, but flag it as unimplemented.
If the class already exists in the confirmedClasses map, don't reset
it (we don't want to stomp a value of true with a value of false) */
if(confirmedClasses.find(*superName) == confirmedClasses.end()) {
confirmedClasses.insert(std::pair<string, bool>(*superName, false));
}
/* Make sure there aren't any attributes defined in this class that are also defined in its parent. */
Groot* groot = cls->getLexParent();
for(auto attr_kv : cls->getMembers()) {
/* Step up the inheritance tree, checking for variables with similar names */
while(superName != nullptr) {
ClassNode* superClass = groot->getClasses()[*superName]; // Get the node for the symbol class. Note that cls->getLexParent() returns Groot.
/* If the this super class has the same variable, throw error */
if(superClass->getMembers().count(attr_kv.first) >= 1) {
std::stringstream msg;
msg << "Error: Instance variable '" << attr_kv.first << "' already exists in a super class '" << *superName << "'" << endl;
throw ScopeCheckErr(msg.str().c_str());
}
superName = superClass->getSuper();
}
}
}
extern "C" G_MODULE_EXPORT void on_GotoClassMenuitem_activate(
GtkWidget * /*widget*/, gpointer /*data*/)
{
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
gClassDiagramView->gotoClass(node->getType()->getName());
}
}
bool QsCodeParser::makeFunctionNode(const QString& synopsis,
QStringList *parentPathPtr,
FunctionNode **funcPtr)
{
QRegExp funcRegExp(
"\\s*([A-Za-z0-9_]+)\\.([A-Za-z0-9_]+)\\s*\\((" +
balancedParens +
")\\)(?:\\s*:\\s*([A-Za-z0-9_]+))?\\s*");
QRegExp paramRegExp(
"\\s*(\\[)?\\s*(?:([A-Za-z0-9_]+)\\s*:\\s*)?"
"([A-Za-z0-9_]+|\\.\\.\\.)\\s*(\\[)?[\\s\\]]*");
if (!funcRegExp.exactMatch(synopsis))
return false;
ClassNode *classe = (ClassNode*)
qsTre->findNode(QStringList(funcRegExp.cap(1)),Node::Class);
if (classe == 0)
return false;
FunctionNode *clone = new FunctionNode(0, funcRegExp.cap(2));
bool optional = false;
QString paramStr = funcRegExp.cap(3);
QStringList params = paramStr.split(",");
QStringList::ConstIterator p = params.begin();
while (p != params.end()) {
if (paramRegExp.exactMatch(*p)) {
if (!paramRegExp.cap(1).isEmpty())
optional = true;
clone->addParameter(Parameter(paramRegExp.cap(3),
"",
paramRegExp.cap(2),
optional ? "undefined" : ""));
if (!paramRegExp.cap(4).isEmpty())
optional = true;
}
else {
delete clone;
return false;
}
++p;
}
QString returnType = funcRegExp.cap(4);
if (!returnType.isEmpty())
clone->setReturnType(returnType);
if (parentPathPtr != 0)
*parentPathPtr = QStringList() << classe->name();
if (funcPtr != 0) {
*funcPtr = clone;
}
else {
delete clone;
}
return true;
}
void TemplateClassInstanceNode::checkSemantic(TemplateArguments* templateArguments)
{
assert(0 == templateArguments);
assert(m_typeNode && m_classTypeNode);
ClassNode* classNode = static_cast<ClassNode*>(m_classTypeNode->m_classNode);
g_errorList.setTemplateClassInstance(this);
classNode->checkSemantic(&m_templateArguments);
g_errorList.setTemplateClassInstance(0);
}
extern "C" G_MODULE_EXPORT void on_ViewSourceMenuitem_activate(
GtkWidget * /*widget*/, gpointer /*data*/)
{
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
const ModelClassifier *classifier = ModelClassifier::getClass(node->getType());
if(classifier && classifier->getModule())
{
gClassDiagramView->viewSource(classifier->getModule()->getModulePath(),
classifier->getLineNum());
}
}
}
extern "C" G_MODULE_EXPORT void on_ClassPreferencesMenuitem_activate(
GtkWidget * /*widget*/, gpointer /*data*/)
{
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
ClassPreferencesDialog dlg;
if(dlg.run(*Builder::getBuilder(), node->getNodeOptions()))
{
gClassDiagramView->getDiagram().changeOptions(getDrawOptions(
gClassDiagramView->getGuiOptions()));
gClassDiagramView->drawToDrawingArea();
}
}
}
void handlePopup(ClassGraph::eAddNodeTypes addType)
{
static int depth = 0;
depth++;
if(depth == 1)
{
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
gClassDiagramView->getDiagram().addRelatedNodesRecurse(
gClassDiagramView->getDiagram().getModelData(),
node->getType(), addType);
gClassDiagramView->updateGraph(true);
}
}
depth--;
}
void handleToggle(GtkWidget *widget, ClassGraph::eAddNodeTypes addType)
{
static int depth = 0;
depth++;
if(depth == 1)
{
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
ClassNode *node = gClassDiagramView->getNode(gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
gClassDiagramView->selectAddClass(node->getType(), addType);
}
}
}
depth--;
}
bool ClassGraph::isNodeTypePresent(ClassNode const &node,
std::vector<ClassNode> const &nodes)
{
auto nodeIter = std::find_if(nodes.begin(), nodes.end(),
[&node](ClassNode const &existingNode)
{ return(node.getType() == existingNode.getType()); });
return (nodeIter != nodes.end());
}
/**
* Checks for inheritance cycles of classes.
*/
void typecheck::CheckScope::checkInheritanceCycles(typecheck::ClassNode* cls) {
Groot* groot = cls->getLexParent();
std::set<ClassNode*> visitedClasses;
ClassNode* cur = cls;
string* superName = cls->getSuper();
while(superName != nullptr) {
if(visitedClasses.find(cur) == visitedClasses.end()) {
visitedClasses.insert(cur);
} else {
std::stringstream msg;
msg << "Error: Class '" << *superName << "' is in an inheritance cycle." << endl;
throw ScopeCheckErr(msg.str().c_str());
}
cur = groot->getClasses()[*superName];
superName = cur->getSuper();
}
}
// This is set in glade.
// gtk_widget_add_events(mDrawingArea, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
// GDK_FOCUS_CHANGE_MASK);
void ClassDiagramView::buttonReleaseEvent(const GdkEventButton *event)
{
if(event->button == 1)
{
// if(abs(event->x - gPressInfo.startPos.x) > 5 ||
// abs(event->y - gPressInfo.startPos.y) > 5)
{
ClassNode *node = getNode(
gStartPosInfo.x, gStartPosInfo.y);
if(node)
{
GraphPoint clickOffset(static_cast<int>(event->x),
static_cast<int>(event->y));
clickOffset.sub(gStartPosInfo);
GraphPoint newPos(node->getPosition());
newPos.add(clickOffset.getZoomed(1/mClassDiagram.getDesiredZoom()));
node->setPosition(newPos);
mClassDiagram.setModified();
drawToDrawingArea();
}
}
// else
{
/*
DiagramNode *node = getNode(event->x, event->y);
if(node)
{
// gDiagramGraph.clearGraph();
// gLastSelectedClassName = node->getClassifier()->getName();
// gDiagramGraph.addNodes(gModelData, node->getClassifier());
// gDiagramGraph.setGraph(gModelData, getDrawOptions());
// gDiagramGraph.drawDiagram(getDrawOptions());
}
*/
}
}
else
{
displayDrawContextMenu(event->button, event->time,
reinterpret_cast<gpointer>(const_cast<GdkEventButton*>(event)));
}
}
void ClassGraph::removeNode(const ClassNode &node)
{
for(size_t i=0; i<mNodes.size(); i++)
{
if(mNodes[i].getType() == node.getType())
{
mNodes.erase(mNodes.begin() + i);
break;
}
}
mModified = true;
}
void SourceFileGenerator::generateCode_AdditionalMethod(FILE* file, MethodNode* methodNode, int indentation)
{
ClassNode* classNode = static_cast<ClassNode*>(methodNode->m_enclosing);
generateCode_TemplateHeader(file, classNode, indentation);
writeStringToFile("inline ", file, indentation);
std::string typeName;
GetClassName(typeName, classNode);
writeStringToFile(typeName.c_str(), file);
if(0 != methodNode->m_passing)
{
generateCode_Token(file, methodNode->m_passing, 0);
}
writeStringToFile(g_strSpaces, 1, file);
writeStringToFile(typeName.c_str(), file);
writeStringToFile("::", file);
generateCode_Identify(file, methodNode->m_name, 0);
generateCode_Token(file, methodNode->m_leftParenthesis, 0);
std::vector<std::pair<TokenNode*, ParameterNode*>> parameterNodes;
methodNode->collectParameterNodes(parameterNodes);
size_t parameterCount = parameterNodes.size();
for(size_t i = 0; i < parameterCount; ++i)
{
if(parameterNodes[i].first)
{
generateCode_Token(file, parameterNodes[i].first, 0);
}
generateCode_Parameter(file, parameterNodes[i].second, methodNode, 0);
}
generateCode_Token(file, methodNode->m_rightParenthesis, 0);
writeStringToFile("\n", file);
char buf[512];
writeStringToFile("{\n", file, indentation);
if("NewArray" == methodNode->m_name->m_str)
{
if(classNode->isValueType())
{
sprintf_s(buf, "return new_array<%s>(count);\n", typeName.c_str());
}
else
{
sprintf_s(buf, "return new_array<::pafcore::RefCountObject<%s>>(count);\n", typeName.c_str());
}
writeStringToFile(buf, file, indentation + 1);
}
else if("NewArrayARC" == methodNode->m_name->m_str)
{
sprintf_s(buf, "return new_array<::pafcore::AtomicRefCountObject<%s>>(count);\n", typeName.c_str());
writeStringToFile(buf, file, indentation + 1);
}
else
{
if("New" == methodNode->m_name->m_str || "Clone" == methodNode->m_name->m_str)
{
if(classNode->isValueType())
{
sprintf_s(buf, "return new %s(", typeName.c_str());
}
else
{
sprintf_s(buf, "return new ::pafcore::RefCountObject<%s>(", typeName.c_str());
}
}
else
{
assert("NewARC" == methodNode->m_name->m_str || "CloneARC" == methodNode->m_name->m_str);
sprintf_s(buf, "return new ::pafcore::AtomicRefCountObject<%s>(", typeName.c_str());
}
writeStringToFile(buf, file, indentation + 1);
for(size_t i = 0; i < parameterCount; ++i)
{
if(i != 0)
{
writeStringToFile(", ", file);
}
writeStringToFile(parameterNodes[i].second->m_name->m_str.c_str(), file);
}
writeStringToFile(");\n", file);
}
writeStringToFile("}\n\n", file, indentation);
}
void DebugPrintVisitor::visit(ClassNode& cl)
{
os << "[Class]" << cl.name() << getPositionString(cl) << std::endl;
}
//----------------------------------------------------------------------------------------------
std::string& CObjectAbstract::GetValueString(std::string &OutValue, bool bSaveAsExternal /*= false*/) const
{
typedef std::pair<std::string, std::string> TPairString;
oes::rflex::AppClassTree &CTree = oes::rflex::GetClassTree();
std::map<std::string, std::string> ValueMap;
ClassNode *pOwnClassNode = CTree.Find(GetType());
if (pOwnClassNode)
{
// prepare storage holder
// Default block name
ValueMap.insert(TPairString("Value", std::string("Name:") + GetName() + " "));
if (GetExternal()){
ValueMap.insert(TPairString("External", GetFilenameTag()));
}
// write down groups map
ClassNode *pClassNode = pOwnClassNode;
while (pClassNode)
{
// general properties
const ClassNode::TVecProperties &VecProps = pClassNode->GetProperties();
ClassNode::TVecPropertyConstIterator IterProp = VecProps.begin();
while (IterProp != VecProps.end())
{
if (ValueMap.find((*IterProp)->GetGroupName()) == ValueMap.end())
{
ValueMap.insert(TPairString((*IterProp)->GetGroupName(), ""));
}
++IterProp;
}
// Interfaces
const ClassNode::TVecInterfaces &VecInterfaces = pClassNode->GetInterfaceProps();
ClassNode::TVecInterfaceConstIter IterIntf = VecInterfaces.begin();
while (IterIntf != VecInterfaces.end())
{
ClassNode *pInfClass = CTree.FindInterface((*IterIntf)->strType);
if (pInfClass)
{
const ClassNode::TVecProperties &IntfPropArray = pInfClass->GetProperties();
ClassNode::TVecPropertyConstIterator &IterPropIntf = IntfPropArray.begin();
while (IterPropIntf != IntfPropArray.end())
{
if (ValueMap.find((*IterPropIntf)->GetGroupName()) == ValueMap.end())
{
ValueMap.insert(TPairString((*IterPropIntf)->GetGroupName(), ""));
}
++IterPropIntf;
}
}
++IterIntf;
}
pClassNode = pClassNode->GetRootNode();
}
// write down values by group name
std::map<std::string, std::string>::iterator IterGroup = ValueMap.begin();
while (IterGroup != ValueMap.end())
{
if (IterGroup->first == "External"){ // already added skip
IterGroup++;
}
ClassNode *pClassNode = pOwnClassNode;
// write
while (pClassNode)
{
const ClassNode::TVecProperties &PropsArray = pClassNode->GetProperties();
ClassNode::TVecPropertyConstIterator IterProp = PropsArray.begin();
while (IterProp != PropsArray.end())
{
if (!bSaveAsExternal && (GetExternal() && !(*IterProp)->IsExternalProp()))
{
++IterProp;
continue;
}
if ((*IterProp)->IsSerializable() && IterGroup->first == (*IterProp)->GetGroupName())
{
char Buff[1024] = {0};
char BuffDefault[1024] = {0};
(*IterProp)->GetProperty((BYTE*)this, Buff);
if ((*IterProp)->GetDefaultValue(BuffDefault)) // check default value skip if necessary
{
if (!strcmp(Buff, BuffDefault))
{
++IterProp;
continue;
}
}
if (!(*IterProp)->IsCommonValue()) // common strategy format [Name:Value]
{
IterGroup->second += std::string((*IterProp)->GetName()) + ":" + std::string(Buff) + " ";
}
else // uninterrupted values purposes (string etc.)
{
IterGroup->second += Buff;
}
}
++IterProp;
}
//Interface Properties
const ClassNode::TVecInterfaces &VecInterfaces = pClassNode->GetInterfaceProps();
ClassNode::TVecInterfaceConstIter IterIntf = VecInterfaces.begin();
while (IterIntf != VecInterfaces.end())
{
ClassNode *pInfClass = CTree.FindInterface((*IterIntf)->strType);
if (pInfClass)
{
const ClassNode::TVecProperties &IntfPropArray = pInfClass->GetProperties();
ClassNode::TVecPropertyConstIterator &IterPropIntf = IntfPropArray.begin();
while (IterPropIntf != IntfPropArray.end())
{
if ((*IterPropIntf)->IsSerializable() && IterGroup->first == (*IterPropIntf)->GetGroupName())
{
char Buff[1024] = {0};
char BuffDefault[1024] = {0};
int MemoryOffsetOverride = 0;
{
SInterfaceDecl* pIntfDecl = pClassNode->GetInterfaceDecl((*IterPropIntf)->GetClassName());
if (pIntfDecl){
MemoryOffsetOverride = pIntfDecl->byteShift;
}
}
(*IterPropIntf)->GetProperty((BYTE*)this + MemoryOffsetOverride, Buff);
if ((*IterPropIntf)->GetDefaultValue(BuffDefault)) // check default value skip if necessary
{
if (!strcmp(Buff, BuffDefault))
{
++IterPropIntf;
continue;
}
}
if (!(*IterPropIntf)->IsCommonValue()) // common strategy format [Name:Value]
{
IterGroup->second += std::string((*IterPropIntf)->GetName()) + ":" + std::string(Buff) + " ";
}
else // uninterrupted values purposes (string etc.)
{
IterGroup->second += Buff;
}
}
++IterPropIntf;
}
}
++IterIntf;
}
pClassNode = pClassNode->GetRootNode();
}
++IterGroup;
}
// write down transient property
char txt[128] = {'\0'};
sprintf(txt, " Transient=\"%i\" ", int(IsTransient()));
OutValue = txt;//" Transient=\"" + boost::lexical_cast<std::string>(int(IsTransient())) + "\" ";
// put together all data
IterGroup = ValueMap.begin();
while (IterGroup != ValueMap.end())
{
if (!IterGroup->second.empty())
{
OutValue += IterGroup->first + std::string("=\"") + IterGroup->second + std::string("\" ");
}
++IterGroup;
}
}
return OutValue;
}
void parser_dump(mrb_state *mrb, mrb_ast_node *tree, int offset)
{
#ifdef ENABLE_STDIO
if (!tree) return;
again:
dump_prefix(offset);
node_type n = tree->getType();
mrb_ast_node *orig = tree;
if(dynamic_cast<UpdatedNode *>(tree)==0)
tree = tree->right();
switch (n) {
case NODE_BEGIN: parser_dump(mrb,(BeginNode *)orig,offset); break;
case NODE_RESCUE: parser_dump(mrb,(RescueNode *)orig,offset); break;
case NODE_ENSURE: parser_dump(mrb,(EnsureNode *)orig,offset); break;
case NODE_LAMBDA:
printf("NODE_LAMBDA:\n");
goto block;
case NODE_BLOCK:
printf("NODE_BLOCK:\n");
block:
parser_dump(mrb,(LambdaCommonNode *)orig,offset);
break;
case NODE_IF:
{
IfNode *in = (IfNode *)orig;
printf("NODE_IF:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, in->cond(), offset+2); //tree->left()
dump_prefix(offset+1);
printf("then:\n");
parser_dump(mrb, in->true_body(), offset+2); //tree->right()->left()
if (in->false_body()) {
dump_prefix(offset+1);
printf("else:\n");
parser_dump(mrb, in->false_body() , offset+2); //tree->right()->right()->left()
}
}
break;
case NODE_AND:
{
AndNode *an = (AndNode *)orig;
printf("NODE_AND:\n");
parser_dump(mrb, an->lhs(), offset+1);
parser_dump(mrb, an->rhs(), offset+1);
}
break;
case NODE_OR:
{
OrNode *an = (OrNode *)orig;
printf("NODE_OR:\n");
parser_dump(mrb, an->lhs(), offset+1);
parser_dump(mrb, an->rhs(), offset+1);
}
break;
case NODE_CASE: {
CaseNode *cn = (CaseNode *)orig;
printf("NODE_CASE:\n");
if (cn->switched_on()) {
parser_dump(mrb, cn->switched_on(), offset+1);
}
tree = cn->cases();
while (tree) {
dump_prefix(offset+1);
printf("case:\n");
dump_recur(mrb, tree->left()->left(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, tree->left()->right(), offset+2);
tree = tree->right();
}
}
break;
case NODE_WHILE:
{
WhileNode *n = (WhileNode *)orig;
printf("NODE_WHILE:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, n->lhs(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, n->rhs(), offset+2);
}
break;
case NODE_UNTIL:
{
UntilNode *n = (UntilNode *)orig;
printf("NODE_UNTIL:\n");
dump_prefix(offset+1);
printf("cond:\n");
parser_dump(mrb, n->lhs(), offset+2);
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, n->rhs(), offset+2);
}
break;
case NODE_FOR:
printf("NODE_FOR:\n");
dump_prefix(offset+1);
parser_dump(mrb,(ForNode *)orig,offset);
break;
case NODE_SCOPE:
printf("NODE_SCOPE:\n");
{
ScopeNode *ns = (ScopeNode *)orig;
const tLocals &n2(ns->locals());
if ( !n2.empty() ) {
dump_prefix(offset+1);
printf("local variables:\n");
dump_prefix(offset+2);
for(auto iter=n2.begin(); iter!=n2.end(); ++iter) {
if ( (iter+1) != n2.end() )
printf(", ");
printf("%s", mrb_sym2name(mrb, *iter));
}
printf("\n");
}
tree = ns->body();
}
offset++;
goto again;
case NODE_FCALL:
case NODE_CALL:
{
CallCommonNode *cn = (CallCommonNode *)orig;
printf("NODE_CALL:\n");
parser_dump(mrb, cn->m_receiver, offset+1);
dump_prefix(offset+1);
printf("method='%s' (%d)\n",
mrb_sym2name(mrb, cn->m_method),
cn->m_method);
CommandArgs *ca = cn->m_cmd_args;
if (ca) {
dump_prefix(offset+1);
printf("args:\n");
dump_recur(mrb, ca->m_args, offset+2);
if (ca->m_blk) {
dump_prefix(offset+1);
printf("block:\n");
parser_dump(mrb, ca->m_blk, offset+2);
}
}
}
break;
case NODE_DOT2:
{
printf("NODE_DOT2:\n");
Dot2Node *nd = (Dot2Node *)orig;
parser_dump(mrb, nd->lhs(), offset+1);
parser_dump(mrb, nd->rhs(), offset+1);
}
break;
case NODE_DOT3:
{
printf("NODE_DOT3:\n");
Dot3Node *nd = (Dot3Node *)orig;
parser_dump(mrb, nd->lhs(), offset+1);
parser_dump(mrb, nd->rhs(), offset+1);
}
break;
case NODE_COLON2:
{
Colon2Node *cn = (Colon2Node *)orig;
printf("NODE_COLON2:\n");
parser_dump(mrb, cn->m_val, offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, cn->m_sym));
}
break;
case NODE_COLON3:{
printf("NODE_COLON3:\n");
dump_prefix(offset+1);
Colon3Node *n = (Colon3Node *)orig;
printf("::%s\n", mrb_sym2name(mrb, n->sym()));
}
break;
case NODE_ARRAY:
printf("NODE_ARRAY:\n");
dump_recur(mrb, ((ArrayNode *)orig)->child(), offset+1);
break;
case NODE_HASH:
{
HashNode *nd = (HashNode *)orig;
printf("NODE_HASH:\n");
tree = nd->child();
while (tree) {
dump_prefix(offset+1);
printf("key:\n");
parser_dump(mrb, tree->left()->left(), offset+2);
dump_prefix(offset+1);
printf("value:\n");
parser_dump(mrb, tree->left()->right(), offset+2);
tree = tree->right();
}
}
break;
case NODE_SPLAT:
printf("NODE_SPLAT:\n");
parser_dump(mrb, ((SplatNode *)orig)->child(), offset+1);
break;
case NODE_ASGN:
{
AsgnNode *an = (AsgnNode *)orig;
printf("NODE_ASGN:\n");
dump_prefix(offset+1);
printf("lhs:\n");
parser_dump(mrb, an->lhs(), offset+2);
dump_prefix(offset+1);
printf("rhs:\n");
parser_dump(mrb, an->rhs(), offset+2);
}
break;
case NODE_MASGN:
{
printf("NODE_MASGN:\n");
dump_prefix(offset+1);
printf("mlhs:\n");
MAsgnNode *mn = (MAsgnNode *)orig;
mrb_ast_node *n2 = mn->lhs();
if (n2->left()) {
dump_prefix(offset+2);
printf("pre:\n");
dump_recur(mrb, n2->left(), offset+3);
}
n2 = n2->right();
if (n2) {
if (n2->left()) {
dump_prefix(offset+2);
printf("rest:\n");
if (n2->left() == (mrb_ast_node*)-1) {
dump_prefix(offset+2);
printf("(empty)\n");
}
else {
parser_dump(mrb, n2->left(), offset+3);
}
}
n2 = n2->right();
if (n2) {
if (n2->left()) {
dump_prefix(offset+2);
printf("post:\n");
dump_recur(mrb, n2->left(), offset+3);
}
}
}
dump_prefix(offset+1);
printf("rhs:\n");
parser_dump(mrb, mn->rhs(), offset+2);
}
break;
case NODE_OP_ASGN: {
OpAsgnNode *opasgn = static_cast<OpAsgnNode *>(tree);
printf("NODE_OP_ASGN:\n");
dump_prefix(offset+1);
printf("lhs:\n");
parser_dump(mrb, opasgn->lhs(), offset+2);
dump_prefix(offset+1);
printf("op='%s' (%d)\n", mrb_sym2name(mrb, opasgn->op_sym), opasgn->op_sym);
parser_dump(mrb, opasgn->rhs(), offset+1);
break;
}
case NODE_SUPER:
{
printf("NODE_SUPER:\n");
SuperNode *x=(SuperNode *)orig;
if (x->hasParams()) {
dump_prefix(offset+1);
printf("args:\n");
dump_recur(mrb, x->args(), offset+2);
if (x->block()) {
dump_prefix(offset+1);
printf("block:\n");
parser_dump(mrb, x->block(), offset+2);
}
}
}
break;
case NODE_ZSUPER:
printf("NODE_ZSUPER\n");
break;
case NODE_RETURN:
printf("NODE_RETURN:\n");
parser_dump(mrb, ((ReturnNode *)orig)->child(), offset+1);
break;
case NODE_YIELD:
printf("NODE_YIELD:\n");
dump_recur(mrb, ((YieldNode *)orig)->child(), offset+1);
break;
case NODE_BREAK:
printf("NODE_BREAK:\n");
parser_dump(mrb, ((BreakNode *)orig)->child(), offset+1);
//parser_dump(mrb, tree, offset+1);
break;
case NODE_NEXT:
printf("NODE_NEXT:\n");
parser_dump(mrb, ((NextNode *)orig)->child(), offset+1);
break;
case NODE_REDO:
printf("NODE_REDO\n");
break;
case NODE_RETRY:
printf("NODE_RETRY\n");
break;
case NODE_LVAR:
{
LVarNode * lvar = (LVarNode *)orig;
printf("NODE_LVAR %s\n", mrb_sym2name(mrb, lvar->sym()));
}
break;
case NODE_GVAR:
{
GVarNode * gvar = (GVarNode *)orig;
printf("NODE_GVAR %s\n", mrb_sym2name(mrb, gvar->sym()));
}
break;
case NODE_IVAR:
{
IVarNode * ivar = (IVarNode *)orig;
printf("NODE_IVAR %s\n", mrb_sym2name(mrb, ivar->sym()));
}
break;
case NODE_CVAR:
{
CVarNode * cvar = (CVarNode *)orig;
printf("NODE_CVAR %s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_CONST:
{
ConstNode * cvar = (ConstNode *)orig;
printf("NODE_CONST %s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_MATCH:
printf("NODE_MATCH:\n");
dump_prefix(offset + 1);
printf("lhs:\n");
parser_dump(mrb, tree->left(), offset + 2);
dump_prefix(offset + 1);
printf("rhs:\n");
parser_dump(mrb, tree->right(), offset + 2);
break;
case NODE_BACK_REF:
printf("NODE_BACK_REF: $%c\n", ((BackRefNode *)orig)->m_ref);
break;
case NODE_NTH_REF:
printf("NODE_NTH_REF: $%d\n", ((NthRefNode *)orig)->m_ref);
break;
case NODE_ARG:
{
ArgNode * var = (ArgNode *)orig;
printf("NODE_ARG %s\n", mrb_sym2name(mrb, var->sym()));
}
break;
case NODE_BLOCK_ARG:
{
printf("NODE_BLOCK_ARG:\n");
parser_dump(mrb, ((BlockArgNode *)orig)->child(), offset+1);
}
break;
case NODE_INT:
{
IntLiteralNode *int_lit = (IntLiteralNode *)orig;
printf("NODE_INT %s base %d\n", int_lit->m_val, int_lit->m_base);
}
break;
case NODE_FLOAT:
printf("NODE_FLOAT %s\n", ((FloatLiteralNode *)orig)->m_val);
break;
case NODE_NEGATE:
printf("NODE_NEGATE\n");
parser_dump(mrb, ((NegateNode *)tree)->child(), offset+1);
break;
case NODE_STR:
{
StrNode *sn=(StrNode *)orig;
printf("NODE_STR \"%s\" len %zu\n", sn->m_str, sn->m_length);
}
break;
case NODE_DSTR:
{
DstrNode *dn = (DstrNode *)orig;
printf("NODE_DSTR\n");
dump_recur(mrb, dn->child(), offset+1);
}
break;
case NODE_XSTR:
printf("NODE_XSTR \"%s\" len %d\n", (char*)tree->left(), (int)(intptr_t)tree->right());
break;
case NODE_DXSTR: {
DxstrNode *dn = (DxstrNode *)orig;
printf("NODE_DXSTR\n");
dump_recur(mrb, dn->child(), offset+1);
}
break;
case NODE_REGX:
printf("NODE_REGX /%s/%s\n", (char*)tree->left(), (char*)tree->right());
break;
case NODE_DREGX:
printf("NODE_DREGX\n");
dump_recur(mrb, tree->left(), offset+1);
dump_prefix(offset);
printf("tail: %s\n", (char*)tree->right()->right()->left());
dump_prefix(offset);
printf("opt: %s\n", (char*)tree->right()->right()->right());
break;
case NODE_SYM:
{
SymNode * cvar = (SymNode *)orig;
printf("NODE_SYM :%s\n", mrb_sym2name(mrb, cvar->sym()));
}
break;
case NODE_SELF:
printf("NODE_SELF\n");
break;
case NODE_NIL:
printf("NODE_NIL\n");
break;
case NODE_TRUE:
printf("NODE_TRUE\n");
break;
case NODE_FALSE:
printf("NODE_FALSE\n");
break;
case NODE_ALIAS:
{
AliasNode *an = (AliasNode *)orig;
printf("NODE_ALIAS %s %s:\n",
mrb_sym2name(mrb, an->m_from),
mrb_sym2name(mrb, an->m_to));
}
break;
case NODE_UNDEF:
printf("NODE_UNDEF");
{
UndefNode *und((UndefNode *)tree);
for(mrb_sym v : und->m_syms) {
printf(" %s", mrb_sym2name(mrb, v));
}
}
printf(":\n");
break;
case NODE_CLASS: {
ClassNode *cn = static_cast<ClassNode *>(tree);
printf("NODE_CLASS:\n");
if (cn->receiver()->left() == (mrb_ast_node*)0) {
dump_prefix(offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else if (cn->receiver()->left() == (mrb_ast_node*)1) {
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else {
parser_dump(mrb, cn->receiver()->left(), offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
if (cn->super()) {
dump_prefix(offset+1);
printf("super:\n");
parser_dump(mrb, cn->super(), offset+2);
}
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, cn->scope()->body(), offset+2);
break;
}
case NODE_MODULE: {
ModuleNode *cn = static_cast<ModuleNode *>(tree);
printf("NODE_MODULE:\n");
if (cn->receiver()->left() == (mrb_ast_node*)0) {
dump_prefix(offset+1);
printf(":%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else if (cn->receiver()->left() == (mrb_ast_node*)1) {
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
else {
parser_dump(mrb, cn->receiver(), offset+1);
dump_prefix(offset+1);
printf("::%s\n", mrb_sym2name(mrb, sym(cn->receiver()->right())));
}
dump_prefix(offset+1);
printf("body:\n");
parser_dump(mrb, cn->scope()->body(), offset+2);
break;
}
case NODE_SCLASS: {
printf("NODE_SCLASS:\n");
SclassNode *scn((SclassNode *)tree);
parser_dump(mrb, scn->scope(), offset+1);
// dump_prefix(offset+1);
// printf("body:\n");
// parser_dump(mrb, scntree->right()->left()->right(), offset+2);
}
break;
case NODE_DEF:
{
DefNode *dn = (DefNode *)orig;
printf("NODE_DEF:\n");
dump_prefix(offset+1);
parser_dump(mrb,dn,offset);
}
break;
case NODE_SDEF:
{
SdefNode *sn = (SdefNode *)orig;
printf("NODE_SDEF:\n");
parser_dump(mrb, sn->receiver(), offset+1);
dump_prefix(offset+1);
printf(":"); // prepend name with ':'
parser_dump(mrb,sn,offset);
}
break;
case NODE_POSTEXE:
printf("NODE_POSTEXE:\n");
parser_dump(mrb, ((PostExeNode *)orig)->child(), offset+1);
break;
case NODE_HEREDOC:{
printf("NODE_HEREDOC:\n");
HeredocNode *hdn((HeredocNode *)tree);
parser_dump(mrb, hdn->contents()->doc->left(), offset+1);
}
break;
default:
printf("node type: %d (0x%x)\n", (int)n, (int)n);
break;
}
#endif
}
void QsCodeParser::quickifyClass(ClassNode *quickClass)
{
QString qtClassName = quickClass->name();
QString bare = quickClass->name();
if (bare != "Qt" && bare != "Object") {
if (bare.startsWith("Q")) {
bare = bare.mid(1);
}
else {
qtClassName.prepend("Q");
classesWithNoQ.insert(bare);
}
}
ClassNode *qtClass = 0;
ClassNode *wrapperClass = 0;
if ((wrapperClass = tryClass("Quick" + bare)) != 0 ||
(wrapperClass = tryClass("QS" + bare + "Class")) != 0) {
qtClass = tryClass(qtClassName);
if (qtClass == 0) {
qtClass = wrapperClass;
wrapperClass = 0;
}
}
else if ((wrapperClass = tryClass("Quick" + bare + "Ptr")) != 0) {
QRegExp ptrToQtType("(Q[A-Za-z0-9_]+)\\s*\\*");
FunctionNode *ctor =
wrapperClass->findFunctionNode(wrapperClass->name());
if (ctor != 0 && !ctor->parameters().isEmpty() &&
ptrToQtType.exactMatch(ctor->parameters().first().leftType()))
qtClassName = ptrToQtType.cap(1);
qtClass = tryClass(qtClassName);
}
else {
wrapperClass = tryClass("Q" + bare + "Ptr");
if (wrapperClass == 0)
wrapperClass = tryClass("Quick" + bare + "Interface");
qtClass = tryClass(qtClassName);
}
if (qtClass == 0) {
if (wrapperClass == 0) {
quickClass->location().warning(tr("Cannot find Qt class '%1'")
.arg(qtClassName));
}
else {
quickClass->location().warning(tr("Cannot find Qt class '%1'"
" wrapped by '%2'")
.arg(qtClassName)
.arg(wrapperClass->name()));
}
return;
}
QList<RelatedClass>::ConstIterator r = qtClass->baseClasses().begin();
while (r != qtClass->baseClasses().end()) {
ClassNode *quickBaseClass = cpp2qs.findClassNode(qsTre,
(*r).node->name());
if (quickBaseClass)
quickClass->addBaseClass((*r).access, quickBaseClass);
++r;
}
if (quickClass->baseClasses().isEmpty() && quickClass->name() != "Object")
quickClass->addBaseClass(Node::Public,
cpp2qs.findClassNode(qsTre,"Object"));
QSet<QString> funcBlackList;
QSet<QString> propertyBlackList;
NodeList children;
if (wrapperClass != 0) {
children = wrapperClass->childNodes();
funcBlackList.insert(wrapperClass->name());
funcBlackList.insert("~" + wrapperClass->name());
}
children += qtClass->childNodes();
for (int pass = 0; pass < 2; pass++) {
NodeList::ConstIterator c = children.begin();
while (c != children.end()) {
if ((*c)->access() != Node::Private &&
(*c)->status() == Node::Commendable) {
if (pass == 0) {
if ((*c)->type() == Node::Enum) {
EnumNode *enume = (EnumNode *) *c;
quickifyEnum(quickClass, enume);
}
else if ((*c)->type() == Node::Property) {
if (!propertyBlackList.contains((*c)->name())) {
PropertyNode *property = (PropertyNode *) *c;
quickifyProperty(quickClass, qtClass, property);
if (!property->getters().isEmpty())
funcBlackList.insert(property->getters().first()->name());
if (!property->setters().isEmpty())
funcBlackList.insert(property->setters().first()->name());
if (!property->resetters().isEmpty())
funcBlackList.insert(property->resetters().first()->name());
propertyBlackList.insert(property->name());
}
}
}
else if ((*c)->type() == Node::Function) {
FunctionNode *func = (FunctionNode *) *c;
quickifyFunction(quickClass, qtClass, func,
funcBlackList.contains((*c)->name()) &&
func->parameters().count() < 2);
}
}
++c;
}
}
setQtDoc(quickClass, qtClass->doc());
classesWithNoQuickDoc.insert(quickClass->name(), quickClass);
}
