Dimajix Developer Blog - Comments

Kaya: OpenGL - Web 2. 0 Style

nospam@example.com (Kaya) — Mon, 03 Dec 2007 20:43:39 +0100

Oh, I didn't know that. This fact actually increases the sexyness of having an OpenGL canvas in Firefox just by using Javascript.

I really almost can't wait to play with this plugin!

James Justin Harrell: OpenGL - Web 2. 0 Style

nospam@example.com (James Justin Harrell) — Mon, 03 Dec 2007 19:46:38 +0100

>> if Javascript turns out to be fast enough

JavaScript 2 (a.k.a ECMAScript 4) is getting optional type declarations that will make JIT compilation much easier. Mozilla is already working on a JIT compiler that will probably appear in Firefox 4.

See http://en.wikipedia.org/wiki/Tamarin_%28JIT%29

Kaya: Visual C++ and vsscanf

nospam@example.com (Kaya) — Wed, 21 Nov 2007 19:56:09 +0100

Thanks for your comment (although the code didn't survive very well). It is a nice idea indeed you have ther. Plus it has no legal questions attached

Michel Julier: Visual C++ and vsscanf

nospam@example.com (Michel Julier) — Wed, 21 Nov 2007 13:12:17 +0100

I just needed a vsscanf() function and I used another solution: I just cut the format string into as many parts as there are variables to be decoded. I also made vscanf() and vfscanf() versions of it but, to be honnest, I didn't test them! vsscanf() works well, however.

Sorry for the comments in French!

A nice improvement would be if there was a way to tell the compiler that it should check the matching between the format and the types of the variables as it does (or does it really?) for scanf.

#include "stdafx.h"

#include
#include
#include
#include

int vsscanf(const char *str, const char *p_format, va_list arg_list){
// fonction qui curieusement n'existe pas chez Microsoft
char *nformat = strdup(p_format);
char *format = nformat;
int i;
int n=0;
int convtot=0;
for (i=0; format[i]; i++){
if (format[i] == '%'){
if (format[i+1] == '%' || format[i+1] == '*' || format[i+1] == '\0')
i++; // pas compté comme variable à allouer, je saute
else { // c'est une variable
if (n==0) // première variable: OK
n++;
else { // deuxième variable: on coupe juste avant
char f[3];
f[1]=format[i+1]; f[2]=format[i+2];
format[i+1]='n'; format[i+2]='\0'; // %n = nombre de caractères lus dans l'entrée
void p = va_arg(arg_list, void );
int lu=-1,conv;
conv = sscanf(str, format, p, &lu);
if (lu==-1){ // échec à la conversion
convtot += conv; // peut-être converti quand même une variable?
break; // mais ensuite on arrête
}
convtot++; // une variable lue
str += lu; // avancer dans l'entrée
format[i+1]=f[1]; format[i+2]=f[2]; // rétablir la chaîne de format
format += i; i = -1; // avancer dans le format
n=0; // on repart avec 0 variable détectée dans la nouvelle chaîne
}
}
}
}
if (format[i]=='\0' && n>0) {
// on est arrivé au bout, et il reste une variable à convertir
void p = va_arg(arg_list, void );
int conv;
conv = sscanf(str, format, p);
convtot += conv;
}
free(nformat);
return convtot;
}

int vscanf(const char *p_format, va_list arg_list){
// fonction qui curieusement n'existe pas chez Microsoft
char *nformat = strdup(p_format);
char *format = nformat;
int i;
int n=0;
int convtot=0;
for (i=0; format[i]; i++){
if (format[i] == '%'){
if (format[i+1] == '%' || format[i+1] == '*' || format[i+1] == '\0')
i++; // pas compté comme variable à allouer, je saute
else { // c'est une variable
if (n==0) // première variable: OK
n++;
else { // deuxième variable: on coupe juste avant
char f[3];
f[1]=format[i+1]; f[2]=format[i+2];
format[i+1]='n'; format[i+2]='\0'; // %n = nombre de caractères lus dans l'entrée
void p = va_arg(arg_list, void );
int lu=-1,conv;
conv = scanf(format, p, &lu);
if (lu==-1){ // échec à la conversion
convtot += conv; // peut-être converti quand même une variable?
break; // mais ensuite on arrête
}
convtot++; // une variable lue
// str += lu; // avancer dans l'entrée
format[i+1]=f[1]; format[i+2]=f[2]; // rétablir la chaîne de format
format += i; i = -1; // avancer dans le format
n=0; // on repart avec 0 variable détectée dans la nouvelle chaîne
}
}
}
}
if (format[i]=='\0' && n>0) {
// on est arrivé au bout, et il reste une variable à convertir
void p = va_arg(arg_list, void );
int conv;
conv = scanf(format, p);
convtot += conv;
}
free(nformat);
return convtot;
}

int vfscanf(FILE *fd, const char *p_format, va_list arg_list){
// fonction qui curieusement n'existe pas chez Microsoft
char *nformat = strdup(p_format);
char *format = nformat;
int i;
int n=0;
int convtot=0;
for (i=0; format[i]; i++){
if (format[i] == '%'){
if (format[i+1] == '%' || format[i+1] == '*' || format[i+1] == '\0')
i++; // pas compté comme variable à allouer, je saute
else { // c'est une variable
if (n==0) // première variable: OK
n++;
else { // deuxième variable: on coupe juste avant
char f[3];
f[1]=format[i+1]; f[2]=format[i+2];
format[i+1]='n'; format[i+2]='\0'; // %n = nombre de caractères lus dans l'entrée
void p = va_arg(arg_list, void );
int lu=-1,conv;
conv = fscanf(fd, format, p, &lu);
if (lu==-1){ // échec à la conversion
convtot += conv; // peut-être converti quand même une variable?
break; // mais ensuite on arrête
}
convtot++; // une variable lue
// str += lu; // avancer dans l'entrée
format[i+1]=f[1]; format[i+2]=f[2]; // rétablir la chaîne de format
format += i; i = -1; // avancer dans le format
n=0; // on repart avec 0 variable détectée dans la nouvelle chaîne
}
}
}
}
if (format[i]=='\0' && n>0) {
// on est arrivé au bout, et il reste une variable à convertir
void p = va_arg(arg_list, void );
int conv;
conv = fscanf(fd, format, p);
convtot += conv;
}
free(nformat);
return convtot;
}

Edgar: A new Direction for OpenGL

nospam@example.com (Edgar) — Thu, 26 Jul 2007 20:59:28 +0200

We could always call it OpenGL 4.0

Kaya Kupferschmidt: Cygwin + Avira = Nogo

nospam@example.com (Kaya Kupferschmidt) — Tue, 05 Jun 2007 09:13:11 +0200

I use Windows for development due to two simple facts:
1. Parts of my code is developed against the Windows API with a Linux port still missing
2. The tools for C++ on Windows are far superior than those on Linux. Especially the debugger in Visual Studio outperforms any Linux solution I have seen so far.
On the other hand for servers I only use Linux, because Linux computers can be remotely managed much better than Windows. Plus I really like the command line (that's the reason why I wouldn't want to have a Windows computer without Cygwin).

James Justin Harrell: Cygwin + Avira = Nogo

nospam@example.com (James Justin Harrell) — Tue, 05 Jun 2007 00:23:54 +0200

Why are you using Windows? I'm not saying you shouldn't, it's just interesting to hear.

It seems that a developer like you could easily handle something like Ubuntu at least.

Kaya Kupferschmidt: Easy Bytecode

nospam@example.com (Kaya Kupferschmidt) — Thu, 08 Mar 2007 09:48:01 +0100

Actually I didn't know that FORTH was using Bytecode before you were telling me so. But that would have been another possibility. As my bytecode is generated using an interface, it shouldn't be too hard to plug in a FORTH bytecode generator.

But it would have to meet some special requirements, like the possibility of calling external functions via a simple string-lookup.

If I find some time (not very likely) I might investigate into a FORTH backend.

Freeman: Easy Bytecode

nospam@example.com (Freeman) — Tue, 06 Mar 2007 09:57:25 +0100

I meant using FORTH "(byte)code" directly. FORTH could parse scripts into FORTH, and there are quality FORTH interpretors and compilers. But, because RPN is so easy to implement, I understand you want to go your own way.

Some time ago, I needed good (but easy) script language for my project, where I want users to specify operations on 2D geometric entities (to define measurement and evaluations of camera detected shapes). I planned to use some kind of RPN and FORTH (I called this GeoForth). But users seems confused, they did not like the RPN (probably never tried Texas Instruments calculators . I ended up with something modern, Prolog-like functional "programs", where users define new entities as evaluations of other entities, and the interpreter (actually, it is compiled into evaluation trees) will sort the evaluations out to provide user with all needed data.

Kaya Kupferschmidt: Easy Bytecode

nospam@example.com (Kaya Kupferschmidt) — Mon, 05 Mar 2007 10:38:24 +0100

Thanks for the pointer to FORTH, indeed it looks similar to my approach, although my frontend does not require RPN notation. But as my frontend (script parser) is separated from the bytecode generator, it is possible to add a RPN based frontend. Maybe I will have a closer look at Forth.

Freeman: Easy Bytecode

nospam@example.com (Freeman) — Sun, 04 Mar 2007 19:15:27 +0100

Did you considered FORTH?

Kaya: What am I doing?

nospam@example.com (Kaya) — Sat, 20 Jan 2007 13:52:17 +0100

At first the NVI pleased me very much because it seperates the (overridable) implementation from the interface. But in my current project at work I learned that the NVI pattern doesn't offer any other real advantage, but it really has some big disadvantages:
1. With pure interfaces (only pure virtual methods) you are much more forced to design a clean interface. There are still many parts in Magnum that do not have such clean interfaces.
2. With pure virtual interfaces you can the computer generate automatically implementations for remote proxies or such. This is a bit harder with the NVI pattern.
3. Finally google did not give me really good causes for using the non-virtual interface pattern.

Fredrik: What am I doing?

nospam@example.com (Fredrik) — Sat, 20 Jan 2007 00:14:17 +0100

Why did you remove NVI?

cinema visitor: Why you want ZFS for Linux

nospam@example.com (cinema visitor) — Tue, 09 Jan 2007 22:10:28 +0100

Or maybe simply buy yourself a real server (SUN) with a real OS and not something homebrewn with a bastel os done by longhaired opensouce communists.

C U

Anonymous: Gigabit Ethernet for SGI Fuel

nospam@example.com () — Wed, 06 Dec 2006 15:27:18 +0100

yes, a Mac Port would be really cool (nice graphics on a nice designed machine).

Looking forward to screenshots

Matthias