FreeBASIC Namespace Project

[marcov]

Indeed I suggested something similar. I am unsure if you are talking about a command to include in the source code, or about a command line switch (or both, if it is implemented like the "LANG" parameter). Anyway, my suggestion is to keep the old behaviour by default, and having to explicitly require the new behaviour for the programs that need it.

With FPC we do both. Commandline + pragma's.

One of the reasons for that is that we have people dual compiling with other compilers (Delphi , ISO Pascal) to contend with, and they rather not modify sources (since that will create potential problems with the other compilers, some of which also parse the non taken branches of IFDEFs).

However people that don't have that situation rather do everything in source (and not maintain potentially IDE specific project files)

[angros47]

I just want to remind, for anyone who thinks to ditch -lang QB and -lang FBLITE, that these modes aren't just for compatibility for older languages: they are also for compatibility with the ISO standard https://en.wikipedia.org/wiki/BASIC#Standards. Dropping support for the standards would mean dropping the right to call FreeBasic a BASIC compiler, since a BASIC compiler is expected to be able to compile a standard-compliant BASIC code.

[speedfixer]

Valuable knowlege.

[MrSwiss]

I hope it is a joke.

On the contrary, this is meant: deadly serious! (I wouldn't want to spend a single Second, on QB (anything)!)

... dropping the right to call FreeBasic a BASIC compiler, since a BASIC compiler is *expected to be able to compile a standard-compliant BASIC code.

*clearly NOT mandatory, therefore, nonsense! (I think, just a simple excuse, to maintain Status Quo!)

[lizard]

Who should decide this internationally, for all countries, who is allowed to call his language "Basic"?

[MrSwiss]

Who should decide this internationally, for all countries, who is allowed to call his language "Basic"?

Well, it's about BASIC (all upper case) because, it is a acronym for: "Beginner's All-purpose Symbolic Instruction Code".
As long as nobody explicitly states: compliant to Standard "xXXXXXx", anybody is free to do anything (FB syntax is clearly BASIC, anyway).

[lizard]

As long as nobody explicitly states: compliant to Standard "xXXXXXx", anybody is free to do anything (the syntax is clearly BASIC, anyway).

I would vote for you.

[dodicat]

<With a light heart>
Personally I think it is a fly by night idea.
Stationary in it's track.
A boulevard of broken dreams (somebody said somewhere)
A road to nowhere.
A lonely place.
using namespace.std
No, that means loading everything, which is not wanted.

Code: Select all

#define gfx
#define std

sub bird
dim as integer xres,yres
gfx.screeninfo xres,yres
dim as double PLOT_grade=2000
dim as double temp1,temp2
#macro sketch(_function,minx,maxx,miny,maxy)
For x As Double=minx To maxx  Step (maxx-minx)/PLOT_GRADE
    dim as double x1=(xres)*(x-minx)/(maxx-minx)
    dim as double y1=(yres)*(_function-maxy)/(miny-maxy)
    gfx.Pset(x1,y1),rgb(0,0,10)
    if abs(x)<1e-3 then
        temp1=x1:temp2=y1
        end if
Next x
gfx.circle (temp1,temp2),50,rgb(0,200,0),,,,f
gfx.circle (temp1-20,temp2-20),10,rgb(200,200,200),,,,f
gfx.circle (temp1+20,temp2-20),10,rgb(200,200,200),,,,f

gfx.circle (temp1-20-5*z,temp2-20),3,rgb(00,00,200),,,,f
gfx.circle (temp1+20-5*z,temp2-20),3,rgb(00,00,200),,,,f

gfx.circle (temp1,temp2),30,rgb(0,0,0),4,5.5
gfx.circle (temp1,temp2-2),30,rgb(0,0,0),4-k/3,5.5+k/3
gfx.circle (temp1,temp2),51,rgb(0,0,10)
#endmacro

static k as integer=1
static z as double
dim pi as double=4*std.atn(1)
     z=z+.02*k
sketch (-std.sin(z*x+z),-(pi),pi,-2,2)
sketch (std.sin(z*x-z),-(pi),pi,-2,2)
gfx.paint (.25*xres,.5*yres),rgb(0,50,120),rgb(0,0,10)
gfx.paint (.75*xres,.5*yres),rgb(0,50,120),rgb(0,0,10)
if z>1.1 then k=-k
if z<-1.1 then k=-k
if z>2*pi then z=0
gfx.window screen (0,0)-(xres,yres)
end sub

Sub Tree(x1 As Single,y1 As Single,size As Single,angle As Single,depth As Single,colb As ulong=0,colL As ulong=0,im as any ptr=0)
    Dim  As Single spread,scale,x2,y2
    spread=25
    scale=.76
    #define incircle(cx,cy,radius,x,y) (cx-x)*(cx-x) +(cy-y)*(cy-y)<= radius*radius
    x2=x1-.25*size*std.Cos(angle*.01745329)
    y2=y1-.25*size*std.Sin(angle*.01745329)
    Static As long count,fx,fy,sz,z
    If count=0 Then  fx=x1:fy=y1:sz=size:z=2^(depth+1)-1
    gfx.Line im,(x1,y1)-(x2,y2),colb
    If count=0 Then  fx=x2:fy=y2:sz=size
    count=count+1
    If count>z Then count=0
    If incircle(fx,fy,(.45*sz),x2,y2)=0 Then gfx.Circle im,(x2,y2),.01*sz,colL 
    If depth>0 Then
        Tree(x2, y2, size * Scale, angle - Spread, depth - 1,colB,colL,im)
        Tree(x2, y2, size * Scale, angle + Spread, depth - 1,colB,colL,im)
    End If
End Sub

Function Regulate(Byval MyFps As long,Byref fps As long=0) As long
        Static As Double timervalue,lastsleeptime,t3,frames
        Var t=std.Timer
        frames+=1
        If (t-t3)>=1 Then t3=t:fps=frames:frames=0
        Var sleeptime=lastsleeptime+((1/myfps)-T+timervalue)*1000
        If sleeptime<1 Then sleeptime=1
        lastsleeptime=sleeptime
        timervalue=T
        Return sleeptime
    End Function

gfx.screenres 1024,768,32
gfx.color , rgb(0,0,20)
dim as any ptr i=gfx.imagecreate(1024,768)

gfx.paint i,(0,0),rgb(0,0,35)
gfx.line i,(0,500)-(1024,768),rgb(0,30,0),bf
for n as long=1 to 200
    gfx.pset i,(rnd*1024,rnd*500)
    next
gfx.line i,(200,768)-(800,500),rgb(30,30,30)
gfx.line i,(850,500)-(900,768),rgb(30,30,30)
gfx.line i,(800,500)-(850,500),rgb(30,30,30)
gfx.paint i,(250,750),rgb(30,30,30),rgb(30,30,30)
var L=std.sqr((825-550)^2 + (768-500)^2)
var dx=(825-550)/L,dy=(768-500)/L
var x=0,y=0
gfx.pset(550,768)
dim as ulong clr
dim as single k=10,g=20
for n as long=1 to 50
    if n and 1 then clr=rgb(100,100,100) else clr=rgb(30,39,30)
    var x=550+dx*g*n,y=768-dy*g*n
    gfx.line i,-(x+dx*k,y-dy*k),clr
    g=.98*g
next 

for n as long=1 to 8
 Tree(-50+std.sqr(9-n)*280,500+n*20,n*40+std.rnd*20,90+(std.rnd*10-std.rnd*20),12,rgb(100,std.rnd*155,0),rgb(0,100,0),i)
next
 
 do
     gfx.screenlock
     gfx.cls
     gfx.put(0,0),i,trans
     bird
     gfx.screenunlock
     std.sleep regulate(50),1
     loop until std.len(std.inkey)

 std.sleep
 gfx.imagedestroy(i) 

[paul doe]

The namespace idea itself is good, but it has not to break retro compatibility. At least, in my opinion.

My suggestion, taking the whole issue one step further:

Fork the Compiler (32/64 bit) to, let's call it: GepardFB (mean/lean/fast), by:

• getting rid of 'backwards compatible languages', aka: -lang FB exclusive
  (thus, getting rid of all 'dialect specific' current issues)
• above allowes then for far quicker fixes to remaining compiler issues (only -lang FB to consider)
• implementation of the 'namespace' idea

All people requiring the 'deprecated' language(s), can stick to ver. 1.05.0 (and, maintain that themselves!).
Developers ressources, thus greatly concentrated on advancing FB, instead of on: maintaining 'backwards compatibility'!

I think that both postures are totally achievable. Retro compatibility should, at this time, not be a priority. FreeBasic needs to evolve sooner or later, and let go of its QB legacy that's quickly becoming a burden.

One possible solution to both issues would be to let the standard namespace as it is, with all those QB quirks, and evolve the namespaces instead. At first, the new namespaces would contain just syntactic-sugar wrappers for the old functions, but far more easy to maintain and develop. Then, only the new functions/namespaces would get updates and fixes, the rest can be left as-is. That way, the language can be developed and the compiler streamlined in a more homogeneous way, without stirring old crap.

Two quick examples of how the code might look like. Don't mind the boilerplate code, or the verbosity (this can be worked out later). Also, .NETisms need not apply (I used them only as an example):

Code: Select all

namespace fb
	namespace datatypes
		enum stringCompareMode
			scAny
			scLiteral
		end enum
		
		type atomic_string as string
	
		type stringEx extends object
			public:
				
				declare constructor()
				declare constructor( byref rhs as const string )
				
				declare operator let( byref rhs as const string )
				declare operator cast() as string
				declare operator []( byval index as uinteger ) as uinteger
				
				declare function inString _
					( _
						byref s as const string, _
						byval compareMode as fb.datatypes.stringCompareMode = scLiteral _
					) as integer
				
				declare function char( byval index as uinteger ) as string
				 
			private:
				as string m_string
		end type
		
		constructor stringEx()
			m_string = ""
		end constructor
		
		constructor stringEx( byref rhs as const string )
			m_string = rhs
		end constructor
				
		operator stringEx.let( byref rhs as const string )
			m_string = rhs
		end operator
		
		operator stringEx.cast() as string
			return( m_string )
		end operator
		
		operator stringEx.[]( byval index as uinteger ) as uinteger
			return( m_string[ index ] )
		end operator

		function stringEx.inString _
			( _
				byref s as const string, _
				byval compareMode as fb.datatypes.stringCompareMode = scLiteral _
			) as integer
		
			select case as const compareMode
				case scAny
					return( instr( m_string, any s ) )
				
				case scLiteral
					return( instr( m_string, s ) )
				
				case else
					'' defaults to literal as FB does
					return( instr( m_string, s ) )
			end select			
		end function
	
		function stringEx.char( byval index as uinteger ) as string
			return( chr( m_string[ index ] ) )
		end function
	end namespace '' datatypes
end namespace '' fb

sub showString( byref s as const string )
	? s
end sub

using fb
using fb.datatypes

dim as string someString = "This is a test"
dim as stringEx myString = someString

showString( someString )
showString( myString )

? instr( someString, "test" )
? instr( someString, any "test" )

? myString.inString( "test" )
? myString.inString( "test", stringCompareMode.scAny )

? chr( someString[ 2 ] )
? chr( myString[ 2 ] )
'' or, more Basic-like:
? myString.char( 2 )

sleep()

Code: Select all

#undef width
#undef screen

namespace fb
	namespace datatypes
		type atomic_integer as integer
		
		type integerEx extends object
			public:
				declare constructor()
				declare constructor( byref rhs as fb.datatypes.atomic_integer )
				
				declare operator let( byref rhs as fb.datatypes.atomic_integer )
				declare operator cast() as fb.datatypes.atomic_integer
				
				declare static function random _
					( _
						byval minValue as fb.datatypes.atomic_integer, _
						byval maxValue as fb.datatypes.atomic_integer _
					) as fb.datatypes.atomic_integer
			
			private:
				as fb.datatypes.atomic_integer m_integer = any
		end type
		
		constructor integerEx()
			m_integer = 0
		end constructor
		
		constructor integerEx( byref rhs as fb.datatypes.atomic_integer )
			m_integer = rhs
		end constructor
		
		operator integerEx.let( byref rhs as fb.datatypes.atomic_integer )
			m_integer = rhs
		end operator
		
		operator integerEx.cast() as fb.datatypes.atomic_integer
			return( m_integer )
		end operator
		
		static function integerEx.random _
		( _
			byval minValue as fb.datatypes.atomic_integer, _
			byval maxValue as fb.datatypes.atomic_integer _
		) as fb.datatypes.atomic_integer
		
			return( int( rnd() * ( maxValue + 1 - minValue ) + minValue ) )
		end function
		
	end namespace '' datatypes
end namespace '' fb

namespace fb
	namespace graphics
		namespace screen
			dim as integer width
			dim as integer height
		end namespace
		
		enum graphicModes
			fb8bit	= 8
			fb16bit	= 16
			fb32bit	= 32
		end enum
				
		sub setScreenResolution _
			( _
				byval w as integer, _
				byval h as integer, _
				byval d as fb.graphics.graphicModes = fb.graphics.graphicModes.fb32bit _
			)
			screenRes( w, h, d )
			
			screen.width = w
			screen.height = h
		end sub
		
		sub drawFilledRectangle _
		( _
			byval x as integer, _
			byval y as integer, _
			byval w as integer, _
			byval h as integer, _
			byval c as ulong _
		)
		
			line( x, y ) - ( x + w - 1, y + h - 1 ), c, bf
		end sub
		
		sub drawFilledCircle _
		( _
			byval x as integer, _
			byval y as integer, _
			byval r as integer, _
			byval c as ulong _
		)
			
			circle( x, y ), r, c, , , , f
		end sub
	end namespace '' graphics
end namespace '' fb

using fb
using fb.datatypes

graphics.setScreenResolution( 800, 600, graphics.graphicModes.fb32bit )
'' screenRes( 800, 600, 32 )
dim as integer scrW, scrH
screenInfo( scrW, scrH )

dim as integer choice

for i as integer = 0 to 1000
	choice = integerEx.random( 0, 1 )
	
	select case as const( choice )
		case 0	
			graphics.drawFilledCircle( _
				integerEx.random( 0, graphics.screen.width - 1 ), _ '' x
				integerEx.random( 0, graphics.screen.height - 1 ), _ '' y
				integerEx.random( 5, 25 ), _ '' radius
				rgb( _ '' color
					integerEx.random( 0, 255 ), _
					integerEx.random( 0, 255 ), _
					integerEx.random( 0, 255 ) ) )
			
			'circle( rnd() * scrW - 1, rnd() * scrH - 1 ), rnd() * 20 + 5, rgb( rnd() * 255, rnd() * 255, rnd() * 255 ), , , , f
		case 1
			graphics.drawFilledRectangle( _
				integerEx.random( 0, graphics.screen.width - 1 ), _ '' x
				integerEx.random( 0, graphics.screen.height - 1 ), _ '' y
				integerEx.random( 100, 300 ), _ '' width
				integerEx.random( 100, 300 ), _ '' height
				rgb( _ '' color
					integerEx.random( 0, 255 ), _
					integerEx.random( 0, 255 ), _
					integerEx.random( 0, 255 ) ) )
			
			'dim as integer x = rnd() * scrW
			'dim as integer y = rnd() * scrH
			'
			'line( x, y ) - ( x + ( rnd() * 200 + 100 ) - 1, y + ( rnd() * 200 + 100 ) - 1 ), rgb( rnd() * 255, rnd() * 255, rnd() * 255 ), bf
	end select
next

sleep()

It should be noted that I'm not advocating a pure-OO interface, just a more streamlined one. I think this is the intention of Imortis, too, but I may be mistaken. This could also bring other benefits, like a simpler grammar (which is also easier on the parser/compiler side of things, too).

[sancho3]

would mean dropping the right to call FreeBasic a BASIC compiler, since a BASIC compiler is expected to be able to compile a standard-compliant BASIC code.

How do you mean? For example both VB6 and VB Net can''t compile QB code.

[marcov]

would mean dropping the right to call FreeBasic a BASIC compiler, since a BASIC compiler is expected to be able to compile a standard-compliant BASIC code.

How do you mean? For example both VB6 and VB Net can''t compile QB code.

And who said QB was standard compliant to begin with ?

[Munair]

And who said QB was standard compliant to begin with ?

You'd have to go to TrueBASIC for that if I'm not mistaken. Victor just liked QB very much, as did many others at the time, including me. FreePascal came about in the same way, while TP was also not standard or ISO Pascal compliant.

[Imortis]

...It should be noted that I'm not advocating a pure-OO interface, just a more streamlined one. I think this is the intention of Imortis, too, but I may be mistaken. This could also bring other benefits, like a simpler grammar (which is also easier on the parser/compiler side of things, too).

Correct. I want to make development on the language itself as simple as possible. This will mean more people will be able to work on it. This means more bug fixes, more progress.

[Tourist Trap]

One possible solution to both issues would be to let the standard namespace as it is, with all those QB quirks, and evolve the namespaces instead. At first, the new namespaces would contain just syntactic-sugar wrappers for the old functions, but far more easy to maintain and develop. Then, only the new functions/namespaces would get updates and fixes, the rest can be left as-is. That way, the language can be developed and the compiler streamlined in a more homogeneous way

Unless someone came here to declare that the way fb works today from the user side (left appart the need of the IDE...) is not in its opinion very satisfying, that is what should be done. I doubt that such an user can be sighted around sincerely ( note that I say user, I know that this is only one half of the affair but I'm in this side ;) ) Other way may work or may not, this way can only be successful.

[paul doe]

Unless someone came here to declare that the way fb works today from the user side (left appart the need of the IDE...) is not in its opinion very satisfying, that is what should be done. I doubt that such an user can be sighted around sincerely ( note that I say user, I know that this is only one half of the affair but I'm in this side ;) ) Other way may work or may not, this way can only be successful.

The problem is not FB, it's QB. FB syntax and behavior was modeled to be compatible with that of QB, and it's not that QB was such a great language to begin with. So, it had to be expanded without breaking compatibility with the crummy syntax of QB. The namespace project could offer both sides what they want: the ones that like the QB way of doing things can use it as always, the rest can move on. Neither of them bothers the other, and if/when people decide to migrate to the new way of doing things, they could do so more or less seamlessly.

I could never understand, for example, why the 'Defenders of the True QB Faith' think that things like this:

Code: Select all

line( x1, y1 ) - ( x2, y2 ), color, b

are more un-BASIC than this:

Code: Select all

drawLine( x1, y1, x2, y2, color )

By the way, the first one draws a rectangle, not a line. See what the whole point is about? If all funtions/subs follow the same signature, adding new functionality/exposing other is simply a matter of code the function, expose the prototype, and that's it. Only one simple parsing function could be used to parse almost all the code (sans control statements and other small quirks, of course), instead of needing a function for each QB keyword in existence. There is much to be gained, and little to lose. Other additional bonus:

Correct. I want to make development on the language itself as simple as possible. This will mean more people will be able to work on it. This means more bug fixes, more progress.

Which can be translated both to development of the compiler itself (the fbc program) and the language (the Basic dialect).