1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
/** \file HowToAddProgrammingLanguages.dox
* \brief How to add support for a programming language
*/
/** \page howToAddProgrammingLanguages How to add support for a programming language
\section LSupport List of things to have "complete" support of a given language in TDevelop
- Implement interface KDevLanguageSupport
- \ref sectionClassWizard
- \ref sectionAttributeMethodWizard
- \ref sectionQtUiSubclassing - (if the language has Qt bindings)
- \ref sectionLanguageParser
- \ref sectionClassStore
- \ref sectionMemoryClassStore
- \ref sectionPersistantClassStore
.
- \ref sectionCodeCompletion
- \ref sectionProblemReporter - (parses source on the fly and reports syntax errors)
- \ref sectionTemplates
- \ref sectionApplicationTemplates
- \ref sectionApplicationImportTemplates
- \ref sectionSourceFileTemplates
- \ref sectionAbbreviationTemplates - (ife expands to an if else statement, etc)
.
- \ref sectionSourceCodeFormater (prettyprint functionality)
- \ref sectionDocumentationTopics
- \ref sectionDebugger
- (gdb/jdb/??? integration)
- \ref sectionCompilerPlugins
.
List of optional things to support a given language in TDevelop:
- \ref sectionEditor - Syntax highlighter - (add to QEditor if not available elsewhere)
- \ref sectionBuildTool (make/ant/etc)
.
Take a look at \ref LangSupportStatus (doc/api/LangSupportStatus.dox file) to see the current status/features of the programming languages currently supported by TDevelop.
\section sectionLanguageSupport Language Support
Any language support should be written as a tdevelop part and implement
KDevLanguageSupport interface (<code>lib/interfaces/kdevlanguagesupport.h</code>).
Implementing methods:
- <code>virtual Features features();</code>
- <code>virtual KMimeType::List mimeTypes();</code>
.
Should be enough for a language support to start working.
TDevelop ships with KDevLang project template. It is a simple language support prototype that can be used when developing language support plugins with TDevelop.
To use it, start a New Project and select: <code>C++->TDevelop->TDevelop Language Support Plugin</code> in the application wizard.
The template is located in <code>languages/cpp/app_templates/kdevlang</code>, you can change it there if you need.
You should look at <code>languages/ruby</code> for a simple language support
implementation. For a compilable language support, consult <code>languages/ada</code> or <code>languages/pascal</code> (they are not so complex as <code>languages/cpp</code>).
Pascal would be a good starting place, as it is the smaller of the two by far.
Language support can offer additional features:
\subsection sectionClassWizard Class wizard
- new class wizard: (See <code>ada, php, cpp</code> or <code>java</code>)
- <code>virtual void addClass();</code>
.
\subsection sectionAttributeMethodWizard Attribute/Method wizard
- add method dialog: (See <code>cpp</code> or <code>java</code>)
- <code>virtual void addMethod(const TQString &className);</code>
.
- add attribute dialog: (See <code>cpp</code> or <code>java</code>)
- <code>virtual void addAttribute(const TQString &className);</code>
.
.
\subsection sectionQtUiSubclassing Qt UI subclassing
If there is a Qt bindings for your language and there is a possibility
to use QtDesigner ui files, you could implement ui subclassing feature:
- <code>virtual QStringList subclassWidget(const TQString& formName);</code>
- <code>virtual QStringList updateWidget(const TQString& formName, const TQString&
fileName);</code>
.
See <code>cpp</code> and <code>java</code> for examples.
\subsection sectionLanguageParser Language parser
In general, class stores can be filled with information without specialized
and complex language parsers (take a look at <code>languages/python</code> that have a very simple python parser) but your language support will surely benefit
from having such. There is a hand-written c/c++ parser (<code>lib/cppparser</code>) in TDevelop that might be used for ObjC or related C-based languages.
Other (not so complex as c++) languages can be parsed by ANTLR based parsers (library is in lib/antlr).
Consult www.antlr.org for a ANTLR documentation and look at <code>languages/java</code>, <code>languages/ada</code> and <code>languages/pascal</code> for an example of using such parsers.
The latest version of ANTLR (2.7.2) has support for Java, C, Pascal, Ada, C++, CIM, HTML, IDL, Verilog, VRML, OCL, ASN.1, and SQL. You can write an ANTLR parser for your own language, of course.
\subsection sectionClassStore Class store
If you write (or have) a language parser, your language support can have
"class store" (a database containing the information about scopes, classes
and methods - their names, names of source files, location in source files,
etc.). Class store libraries can be found at <code>lib/catalog</code> (Catalog) and <code>lib/interfaces</code> (CodeModel).
TDevelop provides class browsers that extract information from a <b>class store</b> and display it in a tree view and toolbar selectors of scopes, classes and methods.
\subsubsection sectionMemoryClassStore Memory class store
CodeModel is the memory class store. It is very efficient and thus it is recommended for using as a project class store. CodeModel libraries are located in <code>lib/interfaces/codemodel.h</code>. The class browser for a CodeModel based stores is <code>parts/classview</code>.
\subsubsection sectionPersistantClassStore Persistant class store
Catalog is the persistant class store for TDevelop. Persistant class store can be used as an information storage for code completion but it also can be used as a class store for the project. Take a look at
<code>languages/cpp</code> for an example of using catalog. Catalog is stored on disk in the database file (Berkeley db) If you use catalog with the project, your class browser will be <code>parts/classbrowser</code>.
\subsection sectionCodeCompletion Code completion
Class store enables you to write a code completion for the language. At the
moment (2003-06-25), code completion is available only to cpp so take a
look at it for an example.
\subsection sectionProblemReporter Problem reporter
If you have a language parser, you can implement <b>problem reporter</b>
functionality for your language. The problem reporter catches errors
reported by a parser and displays it in a problem reporter view.
<code>languages/java</code>, <code>languages/ada</code>, <code>languages/pascal</code> and <code>languages/cpp</code> have problem reporters.
\subsection sectionTemplates Templates
\subsubsection sectionApplicationTemplates Application templates
<b>Application wizard</b> templates should be also written. Appwizard templates are simple to create - consult \ref howToAddApplicationTemplates (HowToAddApplicationTemplates.dox file)
and look at <code>languages/ruby/app_templates/rubyhello</code>, <code>languages/pascal/app_templates/pascalhello</code>, or <code>languages/ada/app_templates/adahello</code>.
\subsubsection sectionApplicationImportTemplates Application import templates
TDevelop has the ability to <b>create a new project from existing projects or source code</b>.
It scans for project files ('*.kdevelop, *.kdevprj, *.studio, *.pro) and if
- it finds a project it extracts the necessary information
- it does not find project files it scans for source files (*.cpp, *.java, *.pl, *.py, ...)
.
and creates a new TDevelop project in the direcotry the user has chosen.
\subsubsection sectionSourceFileTemplates Source file templates
Another thing to do is to create <b>file create templates</b>. They are prototypes for a source files of your language. These prototypes are placed in
<code>parts/filecreate/file-templates</code> dir or <code>languages/YOURLANGUAGE/file_templates</code> and have names equal to the extensions of language source files.
The description of the prototypes is placed in <code>parts/filecreate/template-info.xml</code>.
Consult FileCreatePart (parts/filecreate/README.dox file) and \ref howToAddFileTemplates for further information.
\subsubsection sectionAbbreviationTemplates Code abbreviation templates
TDevelop has a support for <b>code abbreviations</b> so you can add some predefined abbreviations to your language support. Take <code>languages/cpp/cpptemplates</code> as an example.
\subsection sectionSourceCodeFormater Source code formater
Implement a KDevSourceFormater class interface.
To obtain source formater functionality (that is already available to
c-based languages) you can extend astyle library (<code>lib/astyle</code>) that is used by TDevelop to format sources.
Take a look at AStylePart for an example how to do it.
\subsection sectionDocumentationTopics Documentation topics
Add them to <code>languages/YOURLANGUAGE/doc</code>. For an example see <code>languages/python/doc/python.toc</code> and <code>languages/python/doc/python.index</code>
In the end you need to edit the <code>languages/YOURLANGUAGE/doc/Makefile.am</code> file to include the .toc and/or .index file.
\subsection sectionDebugger Debugger
The last thing to have a complete language support in TDevelop is to
write a <b>Debugger </b>. TDevelop already provides GDB support
(<code>languages/cpp/debugger</code>) and JDB (java debugger) support (<code>languages/java/debugger</code>). Take a look at them to get inspiration.
\subsection sectionCompilerPlugins Compiler plugins
There is an ability to create compiler plugin for TDevelop. Compiler plugin provides the compiler configuration dialog which implements command line compiler options.
Compiler plugins must implement KDevCompilerOptions interface.
\section MiscInf Other Info
In the end you should add the language you implemented to the doc/api/LangSupportStatus.dox file and
document your language support part in the way described at \ref howToDocument (doc/api/HowToDocument.dox file).
See also \ref howToAddPlugins (doc/api/HowToAddPlugins.dox file) for an information on how to create a generic TDevelop plugin and how to manage project and global configuration information.
\section sectionEditor Language Editor
To edit source files TDevelop uses any editor that supports the KTextEditor
interface. The current supported editors and their features are listed
in the \ref EditorsSupportStatus (doc/api/EditorsSupportStatus.dox file) page.
In case none of the editors does support advanced editing of sources
written in your language (like code folding, syntax highlighting, line
indentation) you can improve QEditor included in TDevelop (<code>editors/qeditor</code>).
By creating QEditorIndenter and QSourceColorizer descendants you can provide the support for an automatic indentation and syntax highlighting that will be available for sure in TDevelop.
\section sectionBuildTool Build Tool
The language support is important, but it is unusable without a <b>build tool</b>
that can manage projects written on this language. TDevelop
currently provides several build tools. They are:
- ANT build tool
- see AntProjectPart at <code>buildtools/ant</code>
.
- Autotools build tool
- see AutoProjectPart at <code>buildtools/autotools</code>
.
- Custom build tool
- see CustomProjectPart at <code>buildtools/custommakefiles</code>
- (works with custom makefiles, also has ant support)
.
- Generic build tool
- see GenericProjectPart at <code>buildtools/generic</code>
- Offers build tool facilities using project files in xml format (dtd is located in <code>buildtools/generic/kdevxmlproject.dtd</code>).
Those xml files can be converted into makefiles, ant xml files or simply shell scripts using build system plugins.
Build system plugin is an object that implements KDevBuildSystem interface. Build system plugins are located in <code>buildtools/generic/buildsystem</code>.
.
- QMake build tool
- see TrollProjectPart at <code>buildtools/qmake</code>
.
.
Also available:
- Script build tool
- <code>buildtools/script</code>
- (the generic build tool for all scripting languages).
.
- <code>buildtools/pascal</code> and
- <code>buildtools/ada</code>
- <code>buildtools/haskell</code>
.
(They are deprecated build tools that will be replaced with the generic build tool).
Choose your build tool and if the existing build tools doesn't fit
in, extend generic build tool via build system plugin. \ref howToAddGenericBuildTools page (doc/api/HowToAddGenericBuildTools.dox file) helps you to do it.
*/
|
