I started out by writing a small hello world program to test C++ but every time I ran it against GCC I got funky errors. After a while I found out why: g++ is the C++ compiler, GCC only does old-skool C. D0h!
This is the crap you would see:
# gcc test.cpp
/tmp/ccrnZKfr.o: In function `__static_initialization_and_destruction_0(int, int)':
test.cpp:(.text+0x23): undefined reference to `std::ios_base::Init::Init()'
/tmp/ccrnZKfr.o: In function `__tcf_0':
test.cpp:(.text+0x66): undefined reference to `std::ios_base::Init::~Init()'
/tmp/ccrnZKfr.o: In function `main': test.cpp:(.text+0x76):
undefined reference to `std::cout' test.cpp:(.text+0x7b):
undefined reference to `std::basic_ostream<char, char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
/tmp/ccrnZKfr.o:(.eh_frame+0x12): undefined reference to `__gxx_personality_v0'
collect2: ld returned 1 exit status
The guide I found even explains how to make a small Makefile to speed up the process of compiling (and testing). The (short) guide is here.
Right now I'm waiting for Matlab to finish installing and then I'll try to test my Hello World from within Matlab. More info how that works can be found here.
I described in a previous post how I was trying to parse Matlab code. I've given up on this endeavour because it is way too much work (we designated a Matlab compiler as a last resort to get everything stand-alone, we will require Matlab in our project to speed up development).
I will however provide my incomplete and broken grammar, as promised. I hope somebody can use this later on as we have dropped the compiler approach completely.
On a side note, we figured out why nobody has a complete grammar for Matlab: its too darn difficult - if you manage to somehow describe the syntax, implementing it (type checking and internal Matlab functions for example) will be a heck of a lot of work. But it can be done, that much is obvious by now.
// Simple grammar for interpreting Matlab files for the MDDP project.
// Written by Berend Dekens
// Note: this part of the project is abandoned and will not be completed. The grammar is mostly working in Antlr except
// for some dodgy errors. If you find this usefull and/or manage to fix the parser errors, please let me know so I can
// fix the problems.
// Known limitations:
// - No function calls without parenthesis
// Matlab allows function calls in the form of 'function_name arguments'. This is annoying and thus not allowed.
// - No functions calls (period)
// Currently we do not allow function calls at all. Implementing this means supporting a large portion of basic
// Matlab functions and support for declaring new functions across files. This is beyond the scope of this project.
// - No characters or strings in variables
// Our application is matrices and vectors (integers). Boolean logic is included for the sake of logic blocks and loops.
// Grammar rules below, start the grammar with a list of statements
: statement (lineSep+ statementList? )?
: ';' | '\n' | ','
: 'if' parExpression statementList ( lineSep 'elseif' parExpression statementList)* ('else' statementList)? lineSep 'end'
| 'for' Identifier '=' (Identifier | integerLiteral) ':' (Identifier | integerLiteral) (':' (Identifier | integerLiteral))? statementList 'end'
: '(' expression ')'
: conditionalOrExpression (assignmentOperator expression)?
| '(' conditionalOrExpression (assignmentOperator expression)? ')'
: conditionalAndExpression ( '||' conditionalAndExpression )*
: equalityExpression ( '&&' equalityExpression )*
: relationalExpression ( ('==' | '!=') relationalExpression )*
: additiveExpression ( relationalOp additiveExpression )*
: multiplicativeExpression ( ('+' | '-') multiplicativeExpression )*
: unaryExpressionNotPlusMinus ( ( '*' | '/' ) unaryExpressionNotPlusMinus )*
: '~' unaryExpressionNotPlusMinus
| '!' unaryExpressionNotPlusMinus
| primary ('++'|'--')?
| Identifier (identifierSuffix)?
: ('[' ']')+ '.' 'class'
| ('[' expression ']')+ // can also be matched by selector, but do here
: expression (',' expression)*
: '(' expressionList? ')'
: Letter (Letter | Digit)*
Letter : 'a'..'z' | 'A'..'Z';
Digit : '0'..'9';
I hate grammar. I learned the English language when I was 9 years old (as it is not my native language) while trying to read the manual of QuickBasic under DOS. By the time we actually got English lessons in school I was years ahead of most people in my class and even up to the end of high school I never had to read the books we used in school. Instead I read a lot of English books which provided enough sence for the language to stay clear of any official grammar.
But I am drifting here. The problem in computer land is that we use grammar. Every programming language uses a grammar to allow a human to tell the computer what it should do.
Right now I am working on a project where we want to compile Matlab code into C or C++, feed it to GCC and finally upload it into a Virtex IV FPGA. The FPGA has a Sparc V8 compatible CPU (the Leon 2 to be exact) and has a number of auxiliary processorswhich are dedicated for mathematical calculations. For those who care: we are using Montium cores for the calculations.
Even though we pretty much have solved how to drive the whole thing in theory (not in real life as we are just starting), putting it all together is a bit harder.
It starts with the Matlab interpreter and the grammar needed for the interpreter. I've been working with ANTLR in the past to generate a compiler for my own toy language. It supported pretty much everything the old QuickBasic language did except the syntax was much more like Java.
I installed ANTLRWorks to use the shiny new GUI to speed up stuff and immediately ran into a wall: Matlab uses a syntax which sometimes end a statement with a semi-colon (';') and sometimes not, depending if the programmer wants to see intermediate results. I am trying to base my grammar on Java here as it is nice and strict - but stuff like this is rapidly making the adaption a pain in the ...
Another hair puller is the syntax of the 'if' statement: no block structure... Another one lacking the block structure is the function definition. As we are targeting mathematical speedup here and our Virtex board has no display, I will probably sacrifice some stuff to simplify the compiler.
Right now I'm keeping integers and booleans, logic structures like 'if'-'else' and 'for' loops. Floating points, bit operators, function definitions and calls - all have to go. Perhaps I will re-add them later on when needed but right now I don't see any reason to keep them around.
As soon as I got my sub-set grammar complete I will put it up on my site as nobody on the internet seems to have done this before (I found posts from 1992 with no solutions...).
Personally, I like the Substance Look and Feel, even if its a bit heavy to render (the GUI gets a little sluggish if the windows get complex). I downloaded the 4.3 release from the Substance site and used the docs to figure out what argument to feed Java.
Note that Substance has multiple skins, all are a little bit different from eachother. This is why the Substance package has multiple classes you can select for the L&F.
Back to Bleezer. I tried making Bleezer use the Substance L&F by means of the command line. Something like this was supposed to work:
java -Dswing.defaultlaf=org.jvnet.substance.skin.SubstanceBusinessLookAndFeel -cp .:substance.jar -jar Bleezer.jar
However, it did not. For some reason you get this:
Exception in thread "main" java.lang.Error: can't load org.jvnet.substance.skin.SubstanceBusinessLookAndFeelat javax.swing.UIManager.initializeDefaultLAF(UIManager.java:1337)at javax.swing.UIManager.initialize(UIManager.java:1418)at javax.swing.UIManager.maybeInitialize(UIManager.java:1406)at javax.swing.UIManager.getUI(UIManager.java:1003)at javax.swing.JPanel.updateUI(JPanel.java:109)at javax.swing.JPanel.<init>(JPanel.java:69)at javax.swing.JPanel.<init>(JPanel.java:92)at javax.swing.JPanel.<init>(JPanel.java:100)at javax.swing.JRootPane.createGlassPane(JRootPane.java:527)at javax.swing.JRootPane.<init>(JRootPane.java:347)at javax.swing.JFrame.createRootPane(JFrame.java:260)at javax.swing.JFrame.frameInit(JFrame.java:241)at javax.swing.JFrame.<init>(JFrame.java:164)at com.bleezer.Bleezer.<init>(Bleezer.java:112)at com.bleezer.Bleezer.main(Bleezer.java:1556)
After trying a million tests to make sure the JAr file was included I finally ran a decompiler over Bleezer and it looks like Bleezer will only attempt to set the L&F on Windows and MacOS. This means the linux users are stuck with the Metal L&F and Bleezer does not provide an option to change the skin.
In a previous post I showed how you can override the L&F for Bleezer using the command line. For some reason, that same trick won't work here so we'll work around it.
The solution is to add the Bleezer JAR to the class path and then manually specifiy which class should be run. Using this trick, you can make Bleezer use the new L&F.
Putting it all together you could make a launch script to fire up Bleezer using the new Look and Feel:
#!/bin/bashjava -Dswing.defaultlaf=org.jvnet.substance.skin.SubstanceBusinessLookAndFeel -cp .:substance.jar:Bleezer.jar com.bleezer.Bleezer
I'll skip the first 5 (because those plain suck) and skip to the last (and best) 5 options. First up is Thingamablog. This one has a decent interface, is written in Java and resembles a news client. Cool as it may be, it does not support XML RPC style postings, only direct uploads to ftp.
The next one is JBlogEditor. This one is also written in Java but is no longer actively maintained. I had a hard time getting it to run in the first place as the native SWT libraries in there are meant for 32-bit systems. I tried to get the source from SVN but they have no docs on how to build from source and after finally be able to compile it by writing my own compile and run script (which grabs all dependencies) I found out they use a launch system from Eclipse which I don't know.
The 3rd option it QTM for KDE and I can be brief: it looks way to simple for my taste. I will look into it later on to see if its any good as the version reviewed is way older than the current version.
Next up is Flock. Flock is not so much a dedicated blog editor as a fully intergrated package with a Firefox browser and loads of extra stuff, being the "Community Browser" or something. It works straight out of the box on my system but it is way to heavy for just blogging.
Last up is Bleezer, another Java based blogging client. I've actually used that one before so I know it works. The interface is a bit wonky at times but it works fine. The main issue I had in the past is the fact that on linux, it used the default Look and Feel from Java, which is at this time with Java 1.6.0 still Metal. If you don't know it, it looks horrible - something escaped from a Windows 3.1 system or perhaps ancient Solaris.
I finally found a solution for the skinning problem though: use the command line to tell Java to switch the default L&F. I'm currently using something like this:
java -Dswing.defaultlaf=com.sun.java.swing.plaf.gtk.GTKLookAndFeel -jar Bleezer.jar
The only thing driving me nuts at the moment is the fact that the GTK skin is all wrong. Its a lot better than Metal but the fonts are way too small. I have the feeling that this is an issue with the fact that the Qt-to-GtK bridge that I have on my computer is broken because of KDE4 (and thus Qt4.x). At least it is better than nothing and right now I'm even typing this using Bleezer so everything is all good.
I still have high hopes for KBlogger but as long as the 1.0 branch is alpha I will stay clear as it seems to have loads of issues and I can't get it to compile at all.