summaryrefslogtreecommitdiffstats
path: root/kate/part/katejscript.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce4a32fe52ef09d8f5ff1dd22c001110902b60a2 (patch)
tree5ac38a06f3dde268dc7927dc155896926aaf7012 /kate/part/katejscript.cpp
downloadtdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.tar.gz
tdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kate/part/katejscript.cpp')
-rw-r--r--kate/part/katejscript.cpp1169
1 files changed, 1169 insertions, 0 deletions
diff --git a/kate/part/katejscript.cpp b/kate/part/katejscript.cpp
new file mode 100644
index 000000000..024f36500
--- /dev/null
+++ b/kate/part/katejscript.cpp
@@ -0,0 +1,1169 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>
+ Copyright (C) 2005 Joseph Wenninger <jowenn@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "katejscript.h"
+
+#include "katedocument.h"
+#include "kateview.h"
+#include "katefactory.h"
+#include "kateconfig.h"
+#include "kateautoindent.h"
+#include "katehighlight.h"
+#include "katetextline.h"
+
+#include "kateindentscriptabstracts.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <kdebug.h>
+#include <kstandarddirs.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kconfig.h>
+
+#include <kjs/function_object.h>
+#include <kjs/interpreter.h>
+#include <kjs/lookup.h>
+
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qpopupmenu.h>
+#include <qregexp.h>
+#include <qtextstream.h>
+
+
+namespace KJS {
+
+// taken from khtml
+// therefor thx to:
+// Copyright (C) 1999-2003 Harri Porten (porten@kde.org)
+// Copyright (C) 2001-2003 David Faure (faure@kde.org)
+// Copyright (C) 2003 Apple Computer, Inc.
+
+UString::UString(const QString &d)
+{
+ unsigned int len = d.length();
+ UChar *dat = new UChar[len];
+ memcpy(dat, d.unicode(), len * sizeof(UChar));
+ rep = UString::Rep::create(dat, len);
+}
+
+QString UString::qstring() const
+{
+ return QString((QChar*) data(), size());
+}
+
+QConstString UString::qconststring() const
+{
+ return QConstString((QChar*) data(), size());
+}
+
+//BEGIN global methods
+class KateJSGlobalFunctions : public ObjectImp
+{
+ public:
+ KateJSGlobalFunctions(int i, int length);
+ virtual bool implementsCall() const { return true; }
+ virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+ enum {
+ Debug
+ };
+
+ private:
+ int id;
+};
+KateJSGlobalFunctions::KateJSGlobalFunctions(int i, int length) : ObjectImp(), id(i)
+{
+ putDirect(lengthPropertyName,length,DontDelete|ReadOnly|DontEnum);
+}
+Value KateJSGlobalFunctions::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+ switch (id) {
+ case Debug:
+ qDebug("Kate (KJS Scripting): %s", args[0].toString(exec).ascii());
+ return Undefined();
+ default:
+ break;
+ }
+
+ return Undefined();
+}
+//END global methods
+
+} // namespace KJS
+
+//BEGIN JS API STUFF
+
+class KateJSGlobal : public KJS::ObjectImp {
+public:
+ virtual KJS::UString className() const { return "global"; }
+};
+
+class KateJSDocument : public KJS::ObjectImp
+{
+ public:
+ KateJSDocument (KJS::ExecState *exec, KateDocument *_doc);
+
+ KJS::Value get( KJS::ExecState *exec, const KJS::Identifier &propertyName) const;
+
+ KJS::Value getValueProperty(KJS::ExecState *exec, int token) const;
+
+ void put(KJS::ExecState *exec, const KJS::Identifier &propertyName, const KJS::Value& value, int attr = KJS::None);
+
+ void putValueProperty(KJS::ExecState *exec, int token, const KJS::Value& value, int attr);
+
+ const KJS::ClassInfo* classInfo() const { return &info; }
+
+ enum { FullText,
+ Text,
+ TextLine,
+ Lines,
+ Length,
+ LineLength,
+ SetText,
+ Clear,
+ InsertText,
+ RemoveText,
+ InsertLine,
+ RemoveLine,
+ EditBegin,
+ EditEnd,
+ IndentWidth,
+ IndentMode,
+ SpaceIndent,
+ MixedIndent,
+ HighlightMode,
+ IsInWord,
+ CanBreakAt,
+ CanComment,
+ CommentMarker,
+ CommentStart,
+ CommentEnd,
+ Attribute
+ };
+
+ public:
+ KateDocument *doc;
+
+ static const KJS::ClassInfo info;
+};
+
+class KateJSView : public KJS::ObjectImp
+{
+ public:
+ KateJSView (KJS::ExecState *exec, KateView *_view);
+
+ KJS::Value get( KJS::ExecState *exec, const KJS::Identifier &propertyName) const;
+
+ KJS::Value getValueProperty(KJS::ExecState *exec, int token) const;
+
+ void put(KJS::ExecState *exec, const KJS::Identifier &propertyName, const KJS::Value& value, int attr = KJS::None);
+
+ void putValueProperty(KJS::ExecState *exec, int token, const KJS::Value& value, int attr);
+
+ const KJS::ClassInfo* classInfo() const { return &info; }
+
+ enum { CursorLine,
+ CursorColumn,
+ CursorColumnReal,
+ SetCursorPosition,
+ SetCursorPositionReal,
+ Selection,
+ HasSelection,
+ SetSelection,
+ RemoveSelectedText,
+ SelectAll,
+ ClearSelection,
+ SelStartLine,
+ SelStartCol,
+ SelEndLine,
+ SelEndCol
+ };
+
+ public:
+ KateView *view;
+
+ static const KJS::ClassInfo info;
+};
+
+class KateJSIndenter : public KJS::ObjectImp
+{
+ public:
+ KateJSIndenter (KJS::ExecState *exec);
+ /*
+ KJS::Value get( KJS::ExecState *exec, const KJS::Identifier &propertyName) const;
+
+ KJS::Value getValueProperty(KJS::ExecState *exec, int token) const;
+
+ void put(KJS::ExecState *exec, const KJS::Identifier &propertyName, const KJS::Value& value, int attr = KJS::None);
+
+ void putValueProperty(KJS::ExecState *exec, int token, const KJS::Value& value, int attr);
+ */
+ const KJS::ClassInfo* classInfo() const { return &info; }
+
+ enum { OnChar,
+ OnLine,
+ OnNewline,
+ Dummy
+ };
+
+ public:
+
+ static const KJS::ClassInfo info;
+};
+
+#include "katejscript.lut.h"
+
+//END
+
+KateJScript::KateJScript ()
+ : m_global (new KJS::Object (new KateJSGlobal ()))
+ , m_interpreter (new KJS::Interpreter (*m_global))
+ , m_document (new KJS::Object(wrapDocument(m_interpreter->globalExec(), 0)))
+ , m_view (new KJS::Object (wrapView(m_interpreter->globalExec(), 0)))
+{
+ // put some stuff into env., this should stay for all executions, as we keep external
+ // references to the inserted KJS::Objects, this should avoid any garbage collection
+ m_interpreter->globalObject().put(m_interpreter->globalExec(), "document", *m_document);
+ m_interpreter->globalObject().put(m_interpreter->globalExec(), "view", *m_view);
+ m_interpreter->globalObject().put(m_interpreter->globalExec(), "debug",
+ KJS::Object(new KateJSGlobalFunctions(KateJSGlobalFunctions::Debug,1)));
+}
+
+KateJScript::~KateJScript ()
+{
+ delete m_view;
+ delete m_document;
+ delete m_interpreter;
+ delete m_global;
+}
+
+KJS::ObjectImp *KateJScript::wrapDocument (KJS::ExecState *exec, KateDocument *doc)
+{
+ return new KateJSDocument(exec, doc);
+}
+
+KJS::ObjectImp *KateJScript::wrapView (KJS::ExecState *exec, KateView *view)
+{
+ return new KateJSView(exec, view);
+}
+
+bool KateJScript::execute (KateView *view, const QString &script, QString &errorMsg)
+{
+ // no view, no fun
+ if (!view)
+ {
+ errorMsg = i18n("Could not access view");
+ return false;
+ }
+
+ // init doc & view with new pointers!
+ static_cast<KateJSDocument *>( m_document->imp() )->doc = view->doc();
+ static_cast<KateJSView *>( m_view->imp() )->view = view;
+
+ // run the script for real
+ KJS::Completion comp (m_interpreter->evaluate(script));
+
+ if (comp.complType() == KJS::Throw)
+ {
+ KJS::ExecState *exec = m_interpreter->globalExec();
+
+ KJS::Value exVal = comp.value();
+
+ char *msg = exVal.toString(exec).ascii();
+
+ int lineno = -1;
+
+ if (exVal.type() == KJS::ObjectType)
+ {
+ KJS::Value lineVal = KJS::Object::dynamicCast(exVal).get(exec,"line");
+
+ if (lineVal.type() == KJS::NumberType)
+ lineno = int(lineVal.toNumber(exec));
+ }
+
+ errorMsg = i18n("Exception, line %1: %2").arg(lineno).arg(msg);
+ return false;
+ }
+
+ return true;
+}
+
+//BEGIN KateJSDocument
+
+// -------------------------------------------------------------------------
+/* Source for KateJSDocumentProtoTable.
+@begin KateJSDocumentProtoTable 21
+#
+# edit interface stuff + editBegin/End, this is nice start
+#
+ textFull KateJSDocument::FullText DontDelete|Function 0
+ textRange KateJSDocument::Text DontDelete|Function 4
+ textLine KateJSDocument::TextLine DontDelete|Function 1
+ lines KateJSDocument::Lines DontDelete|Function 0
+ length KateJSDocument::Length DontDelete|Function 0
+ lineLength KateJSDocument::LineLength DontDelete|Function 1
+ setText KateJSDocument::SetText DontDelete|Function 1
+ clear KateJSDocument::Clear DontDelete|Function 0
+ insertText KateJSDocument::InsertText DontDelete|Function 3
+ removeText KateJSDocument::RemoveText DontDelete|Function 4
+ insertLine KateJSDocument::InsertLine DontDelete|Function 2
+ removeLine KateJSDocument::RemoveLine DontDelete|Function 1
+ editBegin KateJSDocument::EditBegin DontDelete|Function 0
+ editEnd KateJSDocument::EditEnd DontDelete|Function 0
+#
+# methods from highlight (and around)
+#
+ isInWord KateJSDocument::IsInWord DontDelete|Function 2
+ canBreakAt KateJSDocument::CanBreakAt DontDelete|Function 2
+ canComment KateJSDocument::CanComment DontDelete|Function 2
+ commentMarker KateJSDocument::CommentMarker DontDelete|Function 1
+ commentStart KateJSDocument::CommentStart DontDelete|Function 1
+ commentEnd KateJSDocument::CommentEnd DontDelete|Function 1
+ attribute KateJSDocument::Attribute DontDelete|Function 2
+@end
+
+@begin KateJSDocumentTable 6
+#
+# Configuration properties
+#
+ indentWidth KateJSDocument::IndentWidth DontDelete|ReadOnly
+ indentMode KateJSDocument::IndentMode DontDelete|ReadOnly
+ spaceIndent KateJSDocument::SpaceIndent DontDelete|ReadOnly
+ mixedIndent KateJSDocument::MixedIndent DontDelete|ReadOnly
+ highlightMode KateJSDocument::HighlightMode DontDelete|ReadOnly
+@end
+*/
+
+DEFINE_PROTOTYPE("KateJSDocument",KateJSDocumentProto)
+IMPLEMENT_PROTOFUNC(KateJSDocumentProtoFunc)
+IMPLEMENT_PROTOTYPE(KateJSDocumentProto,KateJSDocumentProtoFunc)
+
+const KJS::ClassInfo KateJSDocument::info = { "KateJSDocument", 0, 0, 0 };
+
+KJS::Value KJS::KateJSDocumentProtoFunc::call(KJS::ExecState *exec, KJS::Object &thisObj, const KJS::List &args)
+{
+ KJS_CHECK_THIS( KateJSDocument, thisObj );
+
+ KateDocument *doc = static_cast<KateJSDocument *>( thisObj.imp() )->doc;
+
+ if (!doc)
+ return KJS::Undefined();
+
+ switch (id)
+ {
+ case KateJSDocument::FullText:
+ return KJS::String (doc->text());
+
+ case KateJSDocument::Text:
+ return KJS::String (doc->text(args[0].toUInt32(exec), args[1].toUInt32(exec), args[2].toUInt32(exec), args[3].toUInt32(exec)));
+
+ case KateJSDocument::TextLine:
+ return KJS::String (doc->textLine (args[0].toUInt32(exec)));
+
+ case KateJSDocument::Lines:
+ return KJS::Number (doc->numLines());
+
+ case KateJSDocument::Length:
+ return KJS::Number (doc->length());
+
+ case KateJSDocument::LineLength:
+ return KJS::Number (doc->lineLength(args[0].toUInt32(exec)));
+
+ case KateJSDocument::SetText:
+ return KJS::Boolean (doc->setText(args[0].toString(exec).qstring()));
+
+ case KateJSDocument::Clear:
+ return KJS::Boolean (doc->clear());
+
+ case KateJSDocument::InsertText:
+ return KJS::Boolean (doc->insertText (args[0].toUInt32(exec), args[1].toUInt32(exec), args[2].toString(exec).qstring()));
+
+ case KateJSDocument::RemoveText:
+ return KJS::Boolean (doc->removeText(args[0].toUInt32(exec), args[1].toUInt32(exec), args[2].toUInt32(exec), args[3].toUInt32(exec)));
+
+ case KateJSDocument::InsertLine:
+ return KJS::Boolean (doc->insertLine (args[0].toUInt32(exec), args[1].toString(exec).qstring()));
+
+ case KateJSDocument::RemoveLine:
+ return KJS::Boolean (doc->removeLine (args[0].toUInt32(exec)));
+
+ case KateJSDocument::EditBegin:
+ doc->editBegin();
+ return KJS::Null ();
+
+ case KateJSDocument::EditEnd:
+ doc->editEnd ();
+ return KJS::Null ();
+
+ case KateJSDocument::IsInWord:
+ return KJS::Boolean( doc->highlight()->isInWord( args[0].toString(exec).qstring().at(0), args[1].toUInt32(exec) ) );
+
+ case KateJSDocument::CanBreakAt:
+ return KJS::Boolean( doc->highlight()->canBreakAt( args[0].toString(exec).qstring().at(0), args[1].toUInt32(exec) ) );
+
+ case KateJSDocument::CanComment:
+ return KJS::Boolean( doc->highlight()->canComment( args[0].toUInt32(exec), args[1].toUInt32(exec) ) );
+
+ case KateJSDocument::CommentMarker:
+ return KJS::String( doc->highlight()->getCommentSingleLineStart( args[0].toUInt32(exec) ) );
+
+ case KateJSDocument::CommentStart:
+ return KJS::String( doc->highlight()->getCommentStart( args[0].toUInt32(exec) ) );
+
+ case KateJSDocument::CommentEnd:
+ return KJS::String( doc->highlight()->getCommentEnd( args[0].toUInt32(exec) ) );
+
+ case KateJSDocument::Attribute:
+ return KJS::Number( doc->kateTextLine(args[0].toUInt32(exec))->attribute(args[1].toUInt32(exec)) );
+ }
+
+ return KJS::Undefined();
+}
+
+KJS::Value KateJSDocument::get( KJS::ExecState *exec, const KJS::Identifier &propertyName) const
+{
+ return KJS::lookupGetValue<KateJSDocument,KJS::ObjectImp>(exec, propertyName, &KateJSDocumentTable, this );
+}
+
+KJS::Value KateJSDocument::getValueProperty(KJS::ExecState *exec, int token) const
+{
+ if (!doc)
+ return KJS::Undefined ();
+
+ switch (token) {
+ case KateJSDocument::IndentWidth:
+ return KJS::Number( doc->config()->indentationWidth() );
+
+ case KateJSDocument::IndentMode:
+ return KJS::String( KateAutoIndent::modeName( doc->config()->indentationMode() ) );
+
+ case KateJSDocument::SpaceIndent:
+ return KJS::Boolean( doc->config()->configFlags() & KateDocumentConfig::cfSpaceIndent );
+
+ case KateJSDocument::MixedIndent:
+ return KJS::Boolean( doc->config()->configFlags() & KateDocumentConfig::cfMixedIndent );
+
+ case KateJSDocument::HighlightMode:
+ return KJS::String( doc->hlModeName( doc->hlMode() ) );
+ }
+
+ return KJS::Undefined ();
+}
+
+void KateJSDocument::put(KJS::ExecState *exec, const KJS::Identifier &propertyName, const KJS::Value& value, int attr)
+{
+ KJS::lookupPut<KateJSDocument,KJS::ObjectImp>(exec, propertyName, value, attr, &KateJSDocumentTable, this );
+}
+
+void KateJSDocument::putValueProperty(KJS::ExecState *exec, int token, const KJS::Value& value, int attr)
+{
+ if (!doc)
+ return;
+}
+
+KateJSDocument::KateJSDocument (KJS::ExecState *exec, KateDocument *_doc)
+ : KJS::ObjectImp (KateJSDocumentProto::self(exec))
+ , doc (_doc)
+{
+}
+
+//END
+
+//BEGIN KateJSView
+
+// -------------------------------------------------------------------------
+/* Source for KateJSViewProtoTable.
+@begin KateJSViewProtoTable 14
+ cursorLine KateJSView::CursorLine DontDelete|Function 0
+ cursorColumn KateJSView::CursorColumn DontDelete|Function 0
+ cursorColumnReal KateJSView::CursorColumnReal DontDelete|Function 0
+ setCursorPosition KateJSView::SetCursorPosition DontDelete|Function 2
+ setCursorPositionReal KateJSView::SetCursorPositionReal DontDelete|Function 2
+ selection KateJSView::Selection DontDelete|Function 0
+ hasSelection KateJSView::HasSelection DontDelete|Function 0
+ setSelection KateJSView::SetSelection DontDelete|Function 4
+ removeSelectedText KateJSView::RemoveSelectedText DontDelete|Function 0
+ selectAll KateJSView::SelectAll DontDelete|Function 0
+ clearSelection KateJSView::ClearSelection DontDelete|Function 0
+@end
+*/
+
+/* Source for KateJSViewTable.
+@begin KateJSViewTable 5
+ selectionStartLine KateJSView::SelStartLine DontDelete|ReadOnly
+ selectionStartColumn KateJSView::SelStartCol DontDelete|ReadOnly
+ selectionEndLine KateJSView::SelEndLine DontDelete|ReadOnly
+ selectionEndColumn KateJSView::SelEndCol DontDelete|ReadOnly
+@end
+*/
+
+DEFINE_PROTOTYPE("KateJSView",KateJSViewProto)
+IMPLEMENT_PROTOFUNC(KateJSViewProtoFunc)
+IMPLEMENT_PROTOTYPE(KateJSViewProto,KateJSViewProtoFunc)
+
+const KJS::ClassInfo KateJSView::info = { "KateJSView", 0, &KateJSViewTable, 0 };
+
+KJS::Value KJS::KateJSViewProtoFunc::call(KJS::ExecState *exec, KJS::Object &thisObj, const KJS::List &args)
+{
+ KJS_CHECK_THIS( KateJSView, thisObj );
+
+ KateView *view = static_cast<KateJSView *>( thisObj.imp() )->view;
+
+ if (!view)
+ return KJS::Undefined();
+
+ switch (id)
+ {
+ case KateJSView::CursorLine:
+ return KJS::Number (view->cursorLine());
+
+ case KateJSView::CursorColumn:
+ return KJS::Number (view->cursorColumn());
+
+ case KateJSView::CursorColumnReal:
+ return KJS::Number (view->cursorColumnReal());
+
+ case KateJSView::SetCursorPosition:
+ return KJS::Boolean( view->setCursorPosition( args[0].toUInt32(exec), args[1].toUInt32(exec) ) );
+
+ case KateJSView::SetCursorPositionReal:
+ return KJS::Boolean( view->setCursorPositionReal( args[0].toUInt32(exec), args[1].toUInt32(exec) ) );
+
+ // SelectionInterface goes in the view, in anticipation of the future
+ case KateJSView::Selection:
+ return KJS::String( view->selection() );
+
+ case KateJSView::HasSelection:
+ return KJS::Boolean( view->hasSelection() );
+
+ case KateJSView::SetSelection:
+ return KJS::Boolean( view->setSelection(args[0].toUInt32(exec),
+ args[1].toUInt32(exec),
+ args[2].toUInt32(exec),
+ args[3].toUInt32(exec)) );
+
+ case KateJSView::RemoveSelectedText:
+ return KJS::Boolean( view->removeSelectedText() );
+
+ case KateJSView::SelectAll:
+ return KJS::Boolean( view->selectAll() );
+
+ case KateJSView::ClearSelection:
+ return KJS::Boolean( view->clearSelection() );
+ }
+
+ return KJS::Undefined();
+}
+
+KateJSView::KateJSView (KJS::ExecState *exec, KateView *_view)
+ : KJS::ObjectImp (KateJSViewProto::self(exec))
+ , view (_view)
+{
+}
+
+KJS::Value KateJSView::get( KJS::ExecState *exec, const KJS::Identifier &propertyName) const
+{
+ return KJS::lookupGetValue<KateJSView,KJS::ObjectImp>(exec, propertyName, &KateJSViewTable, this );
+}
+
+KJS::Value KateJSView::getValueProperty(KJS::ExecState *exec, int token) const
+{
+ if (!view)
+ return KJS::Undefined ();
+
+ switch (token) {
+ case KateJSView::SelStartLine:
+ return KJS::Number( view->selStartLine() );
+
+ case KateJSView::SelStartCol:
+ return KJS::Number( view->selStartCol() );
+
+ case KateJSView::SelEndLine:
+ return KJS::Number( view->selEndLine() );
+
+ case KateJSView::SelEndCol:
+ return KJS::Number( view->selEndCol() );
+ }
+
+ return KJS::Undefined ();
+}
+
+void KateJSView::put(KJS::ExecState *exec, const KJS::Identifier &propertyName, const KJS::Value& value, int attr)
+{
+ KJS::lookupPut<KateJSView,KJS::ObjectImp>(exec, propertyName, value, attr, &KateJSViewTable, this );
+}
+
+void KateJSView::putValueProperty(KJS::ExecState *exec, int token, const KJS::Value& value, int attr)
+{
+ if (!view)
+ return;
+
+
+}
+
+//END
+
+//BEGIN KateJScriptManager
+
+KateJScriptManager::KateJScriptManager ()
+{
+ m_scripts.setAutoDelete (true);
+ collectScripts ();
+}
+
+KateJScriptManager::~KateJScriptManager ()
+{
+}
+
+void KateJScriptManager::collectScripts (bool force)
+{
+// If there's something in myModeList the Mode List was already built so, don't do it again
+ if (!m_scripts.isEmpty())
+ return;
+
+ // We'll store the scripts list in this config
+ KConfig config("katepartjscriptrc", false, false);
+
+ // figure out if the kate install is too new
+ config.setGroup ("General");
+ if (config.readNumEntry ("Version") > config.readNumEntry ("CachedVersion"))
+ {
+ config.writeEntry ("CachedVersion", config.readNumEntry ("Version"));
+ force = true;
+ }
+
+ // Let's get a list of all the .js files
+ QStringList list = KGlobal::dirs()->findAllResources("data","katepart/scripts/*.js",false,true);
+
+ // Let's iterate through the list and build the Mode List
+ for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
+ {
+ // Each file has a group called:
+ QString Group="Cache "+ *it;
+
+ // Let's go to this group
+ config.setGroup(Group);
+
+ // stat the file
+ struct stat sbuf;
+ memset (&sbuf, 0, sizeof(sbuf));
+ stat(QFile::encodeName(*it), &sbuf);
+
+ // If the group exist and we're not forced to read the .js file, let's build myModeList for katepartjscriptrc
+ if (!force && config.hasGroup(Group) && (sbuf.st_mtime == config.readNumEntry("lastModified")))
+ {
+ }
+ else
+ {
+ kdDebug (13050) << "add script: " << *it << endl;
+
+ QString desktopFile = (*it).left((*it).length()-2).append ("desktop");
+
+ kdDebug (13050) << "add script (desktop file): " << desktopFile << endl;
+
+ QFileInfo dfi (desktopFile);
+
+ if (dfi.exists())
+ {
+ KConfig df (desktopFile, true, false);
+ df.setDesktopGroup ();
+
+ // get cmdname, fallback to baseName, if it is empty, therefor not use the kconfig fallback
+ QString cmdname = df.readEntry ("X-Kate-Command");
+ if (cmdname.isEmpty())
+ {
+ QFileInfo fi (*it);
+ cmdname = fi.baseName();
+ }
+
+ if (m_scripts[cmdname])
+ continue;
+
+ KateJScriptManager::Script *s = new KateJScriptManager::Script ();
+
+ s->name = cmdname;
+ s->filename = *it;
+ s->desktopFileExists = true;
+
+ m_scripts.insert (s->name, s);
+ }
+ else // no desktop file around, fall back to scriptfilename == commandname
+ {
+ kdDebug (13050) << "add script: fallback, no desktop file around!" << endl;
+
+ QFileInfo fi (*it);
+
+ if (m_scripts[fi.baseName()])
+ continue;
+
+ KateJScriptManager::Script *s = new KateJScriptManager::Script ();
+
+ s->name = fi.baseName();
+ s->filename = *it;
+ s->desktopFileExists = false;
+
+ m_scripts.insert (s->name, s);
+ }
+ }
+ }
+
+ // Syncronize with the file katepartjscriptrc
+ config.sync();
+}
+
+bool KateJScriptManager::exec( Kate::View *view, const QString &_cmd, QString &errorMsg )
+{
+ // cast it hardcore, we know that it is really a kateview :)
+ KateView *v = (KateView*) view;
+
+ if ( !v )
+ {
+ errorMsg = i18n("Could not access view");
+ return false;
+ }
+
+ //create a list of args
+ QStringList args( QStringList::split( QRegExp("\\s+"), _cmd ) );
+ QString cmd ( args.first() );
+ args.remove( args.first() );
+
+ kdDebug(13050) << "try to exec: " << cmd << endl;
+
+ if (!m_scripts[cmd])
+ {
+ errorMsg = i18n("Command not found");
+ return false;
+ }
+
+ QFile file (m_scripts[cmd]->filename);
+
+ if ( !file.open( IO_ReadOnly ) )
+ {
+ errorMsg = i18n("JavaScript file not found");
+ return false;
+ }
+
+ QTextStream stream( &file );
+ stream.setEncoding (QTextStream::UnicodeUTF8);
+
+ QString source = stream.read ();
+
+ file.close();
+
+ return KateFactory::self()->jscript()->execute(v, source, errorMsg);
+}
+
+bool KateJScriptManager::help( Kate::View *, const QString &cmd, QString &msg )
+{
+ if (!m_scripts[cmd] || !m_scripts[cmd]->desktopFileExists)
+ return false;
+
+ KConfig df (m_scripts[cmd]->desktopFilename(), true, false);
+ df.setDesktopGroup ();
+
+ msg = df.readEntry ("X-Kate-Help");
+
+ if (msg.isEmpty())
+ return false;
+
+ return true;
+}
+
+QStringList KateJScriptManager::cmds()
+{
+ QStringList l;
+
+ QDictIterator<KateJScriptManager::Script> it( m_scripts );
+ for( ; it.current(); ++it )
+ l << it.current()->name;
+
+ return l;
+}
+
+//END
+
+
+
+
+//BEGIN KateJSIndenter
+
+// -------------------------------------------------------------------------
+/* Source for KateJSIndenterProtoTable.
+@begin KateJSIndenterProtoTable 1
+ Dummy KateJSIndenter::Dummy DontDelete
+@end
+*/
+
+/* Source for KateJSIndenterTable.
+@begin KateJSIndenterTable 3
+ onchar KateJSIndenter::OnChar DontDelete
+ onnewline KateJSIndenter::OnNewline DontDelete
+ online KateJSIndenter::OnLine DontDelete
+
+@end
+*/
+
+KateJSIndenter::KateJSIndenter (KJS::ExecState *exec)
+ : KJS::ObjectImp (KateJSViewProto::self(exec))
+{
+}
+
+DEFINE_PROTOTYPE("KateJSIndenter",KateJSIndenterProto)
+IMPLEMENT_PROTOFUNC(KateJSIndenterProtoFunc)
+IMPLEMENT_PROTOTYPE(KateJSIndenterProto,KateJSIndenterProtoFunc)
+
+const KJS::ClassInfo KateJSIndenter::info = { "KateJSIndenter", 0, &KateJSIndenterTable, 0 };
+
+KJS::Value KJS::KateJSIndenterProtoFunc::call(KJS::ExecState *exec, KJS::Object &thisObj, const KJS::List &args)
+{
+ KJS_CHECK_THIS( KateJSIndenter, thisObj );
+
+ return KJS::Undefined();
+}
+
+//END
+
+//BEGIN KateIndentJScriptImpl
+KateIndentJScriptImpl::KateIndentJScriptImpl(const QString& internalName,
+ const QString &filePath, const QString &niceName,
+ const QString &copyright, double version):
+ KateIndentScriptImplAbstract(internalName,filePath,niceName,copyright,version),m_interpreter(0),m_indenter(0)
+{
+}
+
+
+KateIndentJScriptImpl::~KateIndentJScriptImpl()
+{
+ deleteInterpreter();
+}
+
+void KateIndentJScriptImpl::decRef()
+{
+ KateIndentScriptImplAbstract::decRef();
+ if (refCount()==0)
+ {
+ deleteInterpreter();
+ }
+}
+
+void KateIndentJScriptImpl::deleteInterpreter()
+{
+ m_docWrapper=0;
+ m_viewWrapper=0;
+ delete m_indenter;
+ m_indenter=0;
+ delete m_interpreter;
+ m_interpreter=0;
+}
+
+bool KateIndentJScriptImpl::setupInterpreter(QString &errorMsg)
+{
+ if (!m_interpreter)
+ {
+ kdDebug(13050)<<"Setting up interpreter"<<endl;
+ m_interpreter=new KJS::Interpreter(KJS::Object(new KateJSGlobal()));
+ m_docWrapper=new KateJSDocument(m_interpreter->globalExec(),0);
+ m_viewWrapper=new KateJSView(m_interpreter->globalExec(),0);
+ m_indenter=new KJS::Object(new KateJSIndenter(m_interpreter->globalExec()));
+ m_interpreter->globalObject().put(m_interpreter->globalExec(),"document",KJS::Object(m_docWrapper),KJS::DontDelete | KJS::ReadOnly);
+ m_interpreter->globalObject().put(m_interpreter->globalExec(),"view",KJS::Object(m_viewWrapper),KJS::DontDelete | KJS::ReadOnly);
+ m_interpreter->globalObject().put(m_interpreter->globalExec(),"debug", KJS::Object(new
+ KateJSGlobalFunctions(KateJSGlobalFunctions::Debug,1)));
+ m_interpreter->globalObject().put(m_interpreter->globalExec(),"indenter",*m_indenter,KJS::DontDelete | KJS::ReadOnly);
+ QFile file (filePath());
+
+ if ( !file.open( IO_ReadOnly ) )
+ {
+ errorMsg = i18n("JavaScript file not found");
+ deleteInterpreter();
+ return false;
+ }
+
+ QTextStream stream( &file );
+ stream.setEncoding (QTextStream::UnicodeUTF8);
+
+ QString source = stream.read ();
+
+ file.close();
+
+ KJS::Completion comp (m_interpreter->evaluate(source));
+ if (comp.complType() == KJS::Throw)
+ {
+ KJS::ExecState *exec = m_interpreter->globalExec();
+
+ KJS::Value exVal = comp.value();
+
+ char *msg = exVal.toString(exec).ascii();
+
+ int lineno = -1;
+
+ if (exVal.type() == KJS::ObjectType)
+ {
+ KJS::Value lineVal = KJS::Object::dynamicCast(exVal).get(exec,"line");
+
+ if (lineVal.type() == KJS::NumberType)
+ lineno = int(lineVal.toNumber(exec));
+ }
+
+ errorMsg = i18n("Exception, line %1: %2").arg(lineno).arg(msg);
+ deleteInterpreter();
+ return false;
+ } else {
+ return true;
+ }
+ } else return true;
+}
+
+
+inline static bool KateIndentJScriptCall(Kate::View *view, QString &errorMsg, KateJSDocument *docWrapper, KateJSView *viewWrapper,
+ KJS::Interpreter *interpreter, KJS::Object lookupobj,const KJS::Identifier& func,KJS::List params)
+{
+ // no view, no fun
+ if (!view)
+ {
+ errorMsg = i18n("Could not access view");
+ return false;
+ }
+
+ KateView *v=(KateView*)view;
+
+ KJS::Object o=lookupobj.get(interpreter->globalExec(),func).toObject(interpreter->globalExec());
+ if (interpreter->globalExec()->hadException())
+ {
+ errorMsg=interpreter->globalExec()->exception().toString(interpreter->globalExec()).qstring();
+ kdDebug(13050)<<"Exception(1):"<<errorMsg<<endl;
+ interpreter->globalExec()->clearException();
+ return false;
+ }
+
+ // init doc & view with new pointers!
+ docWrapper->doc = v->doc();
+ viewWrapper->view = v;
+
+ /*kdDebug(13050)<<"Call Object:"<<o.toString(interpreter->globalExec()).ascii()<<endl;*/
+ o.call(interpreter->globalExec(),interpreter->globalObject(),params);
+ if (interpreter->globalExec()->hadException())
+ {
+ errorMsg=interpreter->globalExec()->exception().toString(interpreter->globalExec()).ascii();
+ kdDebug(13050)<<"Exception(2):"<<errorMsg<<endl;
+ interpreter->globalExec()->clearException();
+ return false;
+ }
+ return true;
+}
+
+bool KateIndentJScriptImpl::processChar(Kate::View *view, QChar c, QString &errorMsg )
+{
+
+ kdDebug(13050)<<"KateIndentJScriptImpl::processChar"<<endl;
+ if (!setupInterpreter(errorMsg)) return false;
+ KJS::List params;
+ params.append(KJS::String(QString(c)));
+ return KateIndentJScriptCall(view,errorMsg,m_docWrapper,m_viewWrapper,m_interpreter,*m_indenter,KJS::Identifier("onchar"),params);
+}
+
+bool KateIndentJScriptImpl::processLine(Kate::View *view, const KateDocCursor &line, QString &errorMsg )
+{
+ kdDebug(13050)<<"KateIndentJScriptImpl::processLine"<<endl;
+ if (!setupInterpreter(errorMsg)) return false;
+ return KateIndentJScriptCall(view,errorMsg,m_docWrapper,m_viewWrapper,m_interpreter,*m_indenter,KJS::Identifier("online"),KJS::List());
+}
+
+bool KateIndentJScriptImpl::processNewline( class Kate::View *view, const KateDocCursor &begin, bool needcontinue, QString &errorMsg )
+{
+ kdDebug(13050)<<"KateIndentJScriptImpl::processNewline"<<endl;
+ if (!setupInterpreter(errorMsg)) return false;
+ return KateIndentJScriptCall(view,errorMsg,m_docWrapper,m_viewWrapper,m_interpreter,*m_indenter,KJS::Identifier("onnewline"),KJS::List());
+}
+//END
+
+//BEGIN KateIndentJScriptManager
+KateIndentJScriptManager::KateIndentJScriptManager():KateIndentScriptManagerAbstract()
+{
+ m_scripts.setAutoDelete (true);
+ collectScripts ();
+}
+
+KateIndentJScriptManager::~KateIndentJScriptManager ()
+{
+}
+
+void KateIndentJScriptManager::collectScripts (bool force)
+{
+// If there's something in myModeList the Mode List was already built so, don't do it again
+ if (!m_scripts.isEmpty())
+ return;
+
+
+ // We'll store the scripts list in this config
+ KConfig config("katepartindentjscriptrc", false, false);
+#if 0
+ // figure out if the kate install is too new
+ config.setGroup ("General");
+ if (config.readNumEntry ("Version") > config.readNumEntry ("CachedVersion"))
+ {
+ config.writeEntry ("CachedVersion", config.readNumEntry ("Version"));
+ force = true;
+ }
+#endif
+
+ // Let's get a list of all the .js files
+ QStringList list = KGlobal::dirs()->findAllResources("data","katepart/scripts/indent/*.js",false,true);
+
+ // Let's iterate through the list and build the Mode List
+ for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
+ {
+ // Each file has a group ed:
+ QString Group="Cache "+ *it;
+
+ // Let's go to this group
+ config.setGroup(Group);
+
+ // stat the file
+ struct stat sbuf;
+ memset (&sbuf, 0, sizeof(sbuf));
+ stat(QFile::encodeName(*it), &sbuf);
+
+ // If the group exist and we're not forced to read the .js file, let's build myModeList for katepartjscriptrc
+ bool readnew=false;
+ if (!force && config.hasGroup(Group) && (sbuf.st_mtime == config.readNumEntry("lastModified")))
+ {
+ config.setGroup(Group);
+ QString filePath=*it;
+ QString internalName=config.readEntry("internlName","KATE-ERROR");
+ if (internalName=="KATE-ERROR") readnew=true;
+ else
+ {
+ QString niceName=config.readEntry("niceName",internalName);
+ QString copyright=config.readEntry("copyright",i18n("(Unknown)"));
+ double version=config.readDoubleNumEntry("version",0.0);
+ KateIndentJScriptImpl *s=new KateIndentJScriptImpl(
+ internalName,filePath,niceName,copyright,version);
+ m_scripts.insert (internalName, s);
+ }
+ }
+ else readnew=true;
+ if (readnew)
+ {
+ QFileInfo fi (*it);
+
+ if (m_scripts[fi.baseName()])
+ continue;
+
+ QString internalName=fi.baseName();
+ QString filePath=*it;
+ QString niceName=internalName;
+ QString copyright=i18n("(Unknown)");
+ double version=0.0;
+ parseScriptHeader(filePath,&niceName,&copyright,&version);
+ /*save the information for retrieval*/
+ config.setGroup(Group);
+ config.writeEntry("lastModified",sbuf.st_mtime);
+ config.writeEntry("internalName",internalName);
+ config.writeEntry("niceName",niceName);
+ config.writeEntry("copyright",copyright);
+ config.writeEntry("version",version);
+ KateIndentJScriptImpl *s=new KateIndentJScriptImpl(
+ internalName,filePath,niceName,copyright,version);
+ m_scripts.insert (internalName, s);
+ }
+ }
+
+ // Syncronize with the file katepartjscriptrc
+ config.sync();
+}
+
+KateIndentScript KateIndentJScriptManager::script(const QString &scriptname) {
+ KateIndentJScriptImpl *s=m_scripts[scriptname];
+ kdDebug(13050)<<scriptname<<"=="<<s<<endl;
+ return KateIndentScript(s);
+}
+
+void KateIndentJScriptManager::parseScriptHeader(const QString &filePath,
+ QString *niceName,QString *copyright,double *version)
+{
+ QFile f(QFile::encodeName(filePath));
+ if (!f.open(IO_ReadOnly) ) {
+ kdDebug(13050)<<"Header could not be parsed, because file could not be opened"<<endl;
+ return;
+ }
+ QTextStream st(&f);
+ st.setEncoding (QTextStream::UnicodeUTF8);
+ if (!st.readLine().upper().startsWith("/**KATE")) {
+ kdDebug(13050)<<"No header found"<<endl;
+ f.close();
+ return;
+ }
+ // here the real parsing begins
+ kdDebug(13050)<<"Parsing indent script header"<<endl;
+ enum {NOTHING=0,COPYRIGHT=1} currentState=NOTHING;
+ QString line;
+ QString tmpblockdata="";
+ QRegExp endExpr("[\\s\\t]*\\*\\*\\/[\\s\\t]*$");
+ QRegExp keyValue("[\\s\\t]*\\*\\s*(.+):(.*)$");
+ QRegExp blockContent("[\\s\\t]*\\*(.*)$");
+ while ((line=st.readLine())!=QString::null) {
+ if (endExpr.exactMatch(line)) {
+ kdDebug(13050)<<"end of config block"<<endl;
+ if (currentState==NOTHING) break;
+ if (currentState==COPYRIGHT) {
+ *copyright=tmpblockdata;
+ break;
+ }
+ Q_ASSERT(0);
+ }
+ if (currentState==NOTHING)
+ {
+ if (keyValue.exactMatch(line)) {
+ QStringList sl=keyValue.capturedTexts();
+ kdDebug(13050)<<"key:"<<sl[1]<<endl<<"value:"<<sl[2]<<endl;
+ kdDebug(13050)<<"key-length:"<<sl[1].length()<<endl<<"value-length:"<<sl[2].length()<<endl;
+ QString key=sl[1];
+ QString value=sl[2];
+ if (key=="NAME") (*niceName)=value.stripWhiteSpace();
+ else if (key=="VERSION") (*version)=value.stripWhiteSpace().toDouble(0);
+ else if (key=="COPYRIGHT")
+ {
+ tmpblockdata="";
+ if (value.stripWhiteSpace().length()>0) tmpblockdata=value;
+ currentState=COPYRIGHT;
+ } else kdDebug(13050)<<"ignoring key"<<endl;
+ }
+ } else {
+ if (blockContent.exactMatch(line))
+ {
+ QString bl=blockContent.capturedTexts()[1];
+ //kdDebug(13050)<<"block content line:"<<bl<<endl<<bl.length()<<" "<<bl.isEmpty()<<endl;
+ if (bl.isEmpty())
+ {
+ (*copyright)=tmpblockdata;
+ kdDebug(13050)<<"Copyright block:"<<endl<<(*copyright)<<endl;
+ currentState=NOTHING;
+ } else tmpblockdata=tmpblockdata+"\n"+bl;
+ }
+ }
+ }
+ f.close();
+}
+//END
+// kate: space-indent on; indent-width 2; replace-tabs on;