Pascal Gladiator is a free graphical IDE for FPC and debugger front-end for GDB. I'm developing this program for personal use (so I don't have to downgrade to Xcode) but I hope others can make use of it also. To that end I will try to keep updated versions available to the public.

About Pascal Gladiator

90% of all the code appearing in the program is from my web programmers IDE WebScripter and underlying OOP application framework which I developed for it.

The true reason for creating this program was out of desperation in the switch away from CodeWarrior. I like Xcode's interface generally speaking but it's far too complicated and failed on a regular basis citing long lists of obscure linker errors. I was willing to deal with all that but the real killer was the syntax editor. Totally a joke even for Objective-C and they have only now fixed it for version 3.0, which still does not support Pascal well (at all). Looking at black text for 8 hours a day was too painful a thing to imagine and not being able to navigate symbols was even less tolerable.

I aim to keep the interface as clean and simple as I can while providing all the key features needed, which means MUCH less complicated then Xcode or even CodeWarrior but more complicated than Lightweight IDE.

Special thanks to Jonas Maebe for answering FPC related questions, Ingemar Ragnemalm for providing his UNIX process unit ProcessUtils (used for the debugger mainly), the universal interface team and everyone else that helps answer my questions on the mailing list.

The concept was inspired from Lightweight IDE which helped me believe that making a Pascal IDE was actually possible. It feels great that we now have 2 options on the Mac for Pascal and are that less dependent on Apple.

Main Window (version 0.1b)

Requirements

• OS 10.4 only. Currently 10.5 Leopard is not supported and will crash at various times.
• FPC 2.2.2 is recommended.
• Apple Developer Tools for GCC compiler and other tools.

Downloads

• PascalGladiator 0.3b. This update focuses mainly on changes to the debugger but there are other useful updates to the editor also. However there is still a nasty bug I haven't been able to track which causes the application to run slowly after using the debugger. I'm sorry to say the debugger STILL isn't fully functional yet but it does work for short sessions, which after you can just quit the app (it restarts quick). I think the next version will have the debugger working correctly.
• PascalGladiator 0.2b. Big little release with many important changes. However, note that the debugger should just be ignored until I can get the ProcessUtils unit working under FPC 2.2.2. I haven't been able to fix it without support from the developer and he's busy right now. The debugger has new improvments but it's still really slow and now fails to parse symbols with more than 255 characters of value output. I have been using this version to convert a few CW projects and it's doing quite well.
• PascalGladiator 0.1b. This is a pre-release for testing and playing around, nothing is working 100%. NOTE: building/linking frameworks and static libraries is not working until I can figure out how this works. Can anyone offer some help? Clearly frameworks in FPC are off limits to users without expert UNIX knowledge. ;)

Features

• Class browser
• Inserting bookmarks into the symbol menu from code
• Looking up symbols in the reference library
• Debugger GUI which supports most common functions
• Extensible syntax parser which styles project symbols
• Code completion for project symbols
• Navigate symbols and object members by contextual clicking
• Builds application bundles, frameworks, loadable bundles and static/dynamic libraries
• Drag and drop linking of frameworks and libraries
• Project based with drag and drop file management
• Find and replace for single files and projects
• Programable macros which can execute UNIX commands
• Configurable project targets

Development

Planned Development

• Global project search which queries text, symbols and files in one list above the tabs.
• Symbol browser with word filter/search.
• Plug-in units for the debugger which can print custom values of symbols like FSRef.
• Drawer attached to the debugger which you can drag symbols into and watch their values change. Similar to watch points but a GUI version which doesn't actually stop the execution of the program.

Version 0.3b: Changes

• You can navigate errors in the console by using command keys (in the editor menu).
• The first error in the console is auto-selected after a build.
• You can set a label to files (like in the Finder) in the source browser by using file info. The coloring scheme is not very good yet however.
• Document cursor selections are remembered.
• The text in the find window is always selected when the window is opened (via command)
• Creating new empty files inserts a default unit template. This file can be changed at: Contents/Resources/Templates/newfile.txt
• $INCLUDE compiler directives are shown in the symbol browser.
• Records and class symbols are closed in the symbol browser by default to avoid clutter.
• Dragging a file from the project browser into text will insert a {$INCLUDE } compiler directive with the files name.
• There is a function menu in the debugger editor. However, you can still only navigate within the file being debugged.
• Stack frames without valid locations (from library code without source files for example) are not selectable in the stack frame browser and colored grey.
• Common value types (i.e. strings, boolean, numbers, sets etc...) are colored in the debugger.
• File info window (thus far is basically empty) by contextual clicking on a file in the browser. This is also how you can rename folders.
• Function arguments longer than 255 characters are now handled correctly in the debugger.
• Compiling syntax now updates the open documents text. Additionally, in the editor menu you can compile only the open editors syntax.
• Killing the debugger session actually kills the program running.
• Break points are 90% but still some quirks here and there.
• Clearing all break points command in the project menu works. It also clears break points from all related projects!
• Global symbols from the current file are shown in the debugger. This needs more testing as of now.
• The SELF symbol is shown in the debugger.
• Deeply nested pointers print values. However, fields from super-classes will not print yet citing a syntax error.
• Mangled FPC symbol names (like TTABS_CREATE_$__APPEND) are cleaned up in the debuggers stack browser and readable.
• Debugger always scrolls the execution stopped line into view.
• Outstanding debugger issues with speed and long symbol values have been fixed.
• There is a Add Frameworks item in the project menu that opens a choose dialog to the system frameworks folder.

Version 0.2b: Changes

• Find and replace, including find in project with searches current project and all related projects (in the projects group).
• Cleaning projects deletes all items in the temporary build folder.
• Files are marked in the browser if they need compiling (dirty).
• Dynamic libraries and frameworks can be copied into the application bundles framework folder during build by checking the application target option.
• You can now navigate files by contextual clicking on the item in file browser and selecting a function.
• Compiling syntax in the project menu. This needs to be done after making changes or adding new symbols.
• Class browser. Open in the Window menu.
• All open documents are saved before building.
• Debugger editor has a toolbar with the file path and potential modification date warning.
• Projects have a new PROJECTS group for debugging programs that link libraries from external projects. Contextual clicking contains a sources item that lets you open files from the project.
• Builds dynamic libraries and bundles from "Library" programs. Note that only dynamic libraries are tested and working.
• Console window has a status toolbar.
• Syntax errors are shown in the gutter with help tags when you click on them.
• Break points are synched properly when toggled during debugging.
• Fixed a bug causing speed issues when saving files with break points
• Chasing arrows animation appears in the file browser when files are compiling.
• Pointer/object values are printed in the debugger.
• Viewing class hierarchy in contextual menu
• CoreFoundation variables will print values (via CFShow) in the debugger.
Complex types like CFDictionary do not display very well however. Note you can see the raw CFShow output in the console window.
• Fixed incorrect scrolling when saving bug.
• Variables are drawn in red when there values change in the debugger.
• Debugging processes can be killed.
• Option to ignore notes and warnings from the compiler in the application preferences.
• In the help menu are some quick links to FPC documentation in pdf format on the hard disk at /Developer/Documentation/Free Pascal Compiler.
• Jumping to symbols in files outside of the current document nows works correctly.
• Opened symbols in the debugger now remember their state between stack frame changes.
• Crashes are handled in the debugger.

Version 0.1b: Known Bugs

• Projects don't save symbol tables so you can not navigate symbols unless the file has been loaded since launching of the application.
• Jumping to symbols outside the open document is not working.
• Sorry, I left out find and replace for this version. It will be implemented soon.
• The debugger won't print the values of pointers yet.
• The debugger is slow because of a delay inside an event loop timer.
• Function arguments with values longer than 255 characters mess up the debugger.
• The text engine WASTE has serious performance issues when working with files larger than about 1000 lines (he wants $700 for this thing?!). Typing speed is affected as well as saving/loading files with breakpoints and code completion.

Version History:

• 8/28/08 0.3b
• 8/10/08 0.2b
• 7/27/08 0.1b

Contact

Please report anything of use or your ideas. Ryan Joseph