Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version
Go to top

Bird Programming Language: Part 1

, 1 Jan 2013
A new general purpose language that aims to be fast, high level and simple to use.
Bird-noexe.zip
Bird
Archives
crt2.o
crtbegin.o
crtend.o
libadvapi32.a
libcomctl32.a
libcomdlg32.a
libgcc.a
libgdi32.a
libglu32.a
libkernel32.a
libmingw32.a
libmingwex.a
libmoldname.a
libmsvcrt.a
libopengl32.a
libshell32.a
libstdc++.a
libuser32.a
libwinmm.a
libwsock32.a
Libraries
BirdCore
Array.bird
BigInteger.bird
BinaryRW.bird
BirdCore.a
BirdCore.blib
CategoryData.dat
Console.bird
Convert.bird
Debug.bird
Entry.bird
Environment.bird
Exception.bird
Float.bird
LEB128.bird
Math.bird
Memory.bird
Object.bird
Random.bird
Reflection.bird
StandardC.bird
Stream.bird
String.bird
ToLowerData.dat
ToUpperData.dat
Types.bird
ValueType.bird
Win32.bird
x86Helper.bird
BlitzMax
.bmx
Launcher.bmx.gui.release.win32.x86.o
appstub.release.win32.x86.a
bank.release.win32.x86.a
bankstream.release.win32.x86.a
blitz.release.win32.x86.a
BlitzMax.a
BlitzMax.bird
BlitzMax.blib
d3d7max2d.release.win32.x86.a
d3d9max2d.release.win32.x86.a
directx.release.win32.x86.a
dxgraphics.release.win32.x86.a
event.release.win32.x86.a
filesystem.release.win32.x86.a
font.release.win32.x86.a
glgraphics.release.win32.x86.a
glmax2d.release.win32.x86.a
graphics.release.win32.x86.a
hook.release.win32.x86.a
keycodes.release.win32.x86.a
Launcher.bmx
libpng.release.win32.x86.a
linkedlist.release.win32.x86.a
math.release.win32.x86.a
max2d.release.win32.x86.a
opengl.release.win32.x86.a
pixmap.release.win32.x86.a
pngloader.release.win32.x86.a
polledinput.release.win32.x86.a
standardio.release.win32.x86.a
stdc.release.win32.x86.a
stream.release.win32.x86.a
system.release.win32.x86.a
textstream.release.win32.x86.a
win32.release.win32.x86.a
zlib.release.win32.x86.a
PrgLinec.bmx
Samples
Circles
Circles.bird
CppMain.bird
Fire
Fire.bird
Higher Order Functions
C#
Higher Order Functions.v11.suo
Properties
Test.bird
msvcrt.lib
Reflection
Reflection.bird
Squares
Squares.bird
Template
Template.bird
Source
Base
Bird.v11.suo
Expressions
Identifiers
Languages
NativeCode
Properties
Recognizers
Expressions
Scopes
x86
Thumbs.db
Bird.zip
crt2.o
crtbegin.o
crtend.o
libadvapi32.a
libcomctl32.a
libcomdlg32.a
libgcc.a
libgdi32.a
libglu32.a
libkernel32.a
libmingw32.a
libmingwex.a
libmoldname.a
libmsvcrt.a
libopengl32.a
libshell32.a
libstdc++.a
libuser32.a
libwinmm.a
libwsock32.a
Binaries
ar.exe
Bird.exe
fasm.exe
ld.exe
libiconv-2.dll
libintl-8.dll
Array.bird
BigInteger.bird
BinaryRW.bird
BirdCore.a
BirdCore.blib
CategoryData.dat
Console.bird
Convert.bird
Debug.bird
Entry.bird
Environment.bird
Exception.bird
Float.bird
LEB128.bird
Math.bird
Memory.bird
Object.bird
Random.bird
Reflection.bird
StandardC.bird
Stream.bird
String.bird
ToLowerData.dat
ToUpperData.dat
Types.bird
ValueType.bird
Win32.bird
x86Helper.bird
Launcher.bmx.gui.release.win32.x86.o
appstub.release.win32.x86.a
bank.release.win32.x86.a
bankstream.release.win32.x86.a
blitz.release.win32.x86.a
BlitzMax.a
BlitzMax.bird
BlitzMax.blib
d3d7max2d.release.win32.x86.a
d3d9max2d.release.win32.x86.a
directx.release.win32.x86.a
dxgraphics.release.win32.x86.a
event.release.win32.x86.a
filesystem.release.win32.x86.a
font.release.win32.x86.a
glgraphics.release.win32.x86.a
glmax2d.release.win32.x86.a
graphics.release.win32.x86.a
hook.release.win32.x86.a
keycodes.release.win32.x86.a
Launcher.bmx
libpng.release.win32.x86.a
linkedlist.release.win32.x86.a
math.release.win32.x86.a
max2d.release.win32.x86.a
opengl.release.win32.x86.a
pixmap.release.win32.x86.a
pngloader.release.win32.x86.a
polledinput.release.win32.x86.a
standardio.release.win32.x86.a
stdc.release.win32.x86.a
stream.release.win32.x86.a
system.release.win32.x86.a
textstream.release.win32.x86.a
win32.release.win32.x86.a
zlib.release.win32.x86.a
PrgLinec.bmx
PrgLinec.exe
Circles.bird
CppMain.bird
Fire.bird
Higher Order Functions.v11.suo
Test.bird
msvcrt.lib
Reflection.bird
Squares.bird
Template.bird
Bird.v11.suo
Thumbs.db
examples.zip
Examples
As.exe
AsLibs.a
PerfTest
Launcher.bmx
Squares
.bmx
Launcher.bmx
Template
Launcher.bmx
source.zip
Anonymus 7_1
Anonymus.csproj.user
Anonymus.idc
Anonymus.pidb
Anonymus.suo
Anonymus.userprefs
Base
Expressions
Lib
Long
LongDivTest.bmx
ULongConv.bmx
Math
MISZ
AsLibs.a
PerfTest
Launcher.bmx
Squares
Launcher.bmx
Template
Launcher.bmx
PrgLinec.bmx
PrgLinec.exe
Properties
Scopes
Txt
Asm.docx
Code.docx
Lib.aslib
~$Code.docx
x86
using System;
using System.Collections.Generic;
using System.Threading;

namespace Anonymus
{
    public enum MessageSeverity
    {
        Error = 0,
        Warning = 1,
        Info = 2
    }

	public enum MessageId
	{
		UnknownError = 1000,
		NoMacro,
		NotValidName,
		WrongParamList,
		NoMatchingIf,
		MacroAlreadyDefined,
		NoParamName,
		ParamCount,
		NoEndif,
		UnknownType,
		WrongDefinition,
		// ConstStringErr,
		ZNumErr,
		CalcNoId,
		ConstNumErr,
		UnknownOp,
		CantCall,
		MustConst,
		CannotConvert,
		InvalidScopeIndent,
		UnknownId,
		OpsInGblScope,
		NotExpected,
		PreprocError,
		TypeNotSpecified,
		IdAlreadyDefined,
		DeficientExpr,
		MustWhile,
		LoopWithoutDo,
		StaticErr,
		CantOpApplied,
		CallingNotFunc,
		MissingParam,
		NotVariable,
		MissingThen,
		AsmNotRId,
		NotAllPathReturn,
		AssignRValue,
		LitType,
		UnknownCommand,
		ImplicitlyCast,
		ForToDownToUntil,
		NoForVar,
		MoreForVar,
		NoForInitValue,
		NeedThenElse,
		WrongSettings,
		EntryNotFound,
		EntryNotSpecified,
		ImpExpGlbScope,
		CannotConvertConst,
		UnassignedVar,
		AddressOfRValue,
		MustBeGlobal,
		Untyped,
		CannotDeclVar,
		CantOpApplied2,
		UnknownType2,
		SameEnumValue,
		DefFuncParamVal,
		UnBreakCountinueable,
		CaseWithoutSwitch,
		CaseSystaxErr,
		SwitchNoCaseDef,
		SwitchAlreadyHasDef,
		EnumValOverflow,
		LabelAlreadyDefined,
		UnknownLabel,
		ConstOutOfRange,
		ReadOnly,
		CallConvErr,
		Unnamed,
		CannotInherit,
		TypeCannotBeSpecified,
		NoConstructor,
		CantDeclare,
		Static,
		NonStatic,
		ExternNonMSCoff,
		ModParamsNotAllowed,
		FuncCannotHaveInnerScope,
		CannotGetSize,
		MacroWithoutValue,
		VarFuncRetType,
		NonStaticInStaticClass,
		SealedErr,
		StaticSealed,
		CannotInheritStatic,
		CannotInheritSealed,
		NoParamLessConstructor,
		HasntGotMembers,
		CycleInStructs,
		MustBeUnnamed,
		UnassignedVar2,
		CannotBeThisType,
		MustBeNamed,
		MustHaveInitVal,
		FileDoesntExists,
		InvalidFile,

		PreprocWarning = 2000,
		EmptyScope,
		CoreCountWarning,
		AssignSameVar,
		VarAssignWoUsing,
		UnreacheableCode,
		UnusedId,
		CastToSameType,
		CmpSameVariable,

		NoMessage = 3000,
		PreprocInfo,
		CantReadFile,
	}

    
    public struct Message
    {
        public MessageSeverity Severity;
        public string Description;

		public static Dictionary<MessageId, string> Errors;

		static Message()
		{
			Errors = new Dictionary<MessageId, string>();

			// Errors
			Errors.Add(MessageId.NoMacro, "A makró nincs definiálva");
			Errors.Add(MessageId.NotValidName, "Nem megfelelő karaktert tartalmaz az elnevezés");
			Errors.Add(MessageId.WrongParamList, "A paraméterlista hibát tartalmaz");
			Errors.Add(MessageId.NoMatchingIf, "Nincsen ehhez tartozó feltétel");
			Errors.Add(MessageId.MacroAlreadyDefined, "A makró már definiálva van");
			Errors.Add(MessageId.NoParamName, "Nincs megadva egy paraméter");
			Errors.Add(MessageId.ParamCount, "Nem megfelelő a paraméterek száma");
			Errors.Add(MessageId.NoEndif, "A feltétel nincs lezárva");
			Errors.Add(MessageId.UnknownType, "Ismeretlen típus");
			Errors.Add(MessageId.WrongDefinition, "Nem megfelelő a definíció");
			// Errors.Add(MessageId.ConstStringErr, "A string nincs lezárva");
			Errors.Add(MessageId.ZNumErr, "A zárójelnek nincs párja");
			Errors.Add(MessageId.CalcNoId, "A kifejezés hiányos");
			Errors.Add(MessageId.ConstNumErr, "A számot nem lehet felismerni");
			Errors.Add(MessageId.UnknownOp, "Ismeretlen operátor a kifejezésben");
			Errors.Add(MessageId.CantCall, "Ezt a változót nem lehet meghívni");
			Errors.Add(MessageId.MustConst, "Ennek az értéknek konstansnak kell lennie");
			Errors.Add(MessageId.CannotConvert, "A(z) '{0}' típusú érték nem kovertálható '{1}' típusra");
			Errors.Add(MessageId.InvalidScopeIndent, "Nem megfelelő a sor elötti whitespace karakterek száma");
			Errors.Add(MessageId.UnknownId, "Ismeretlen megkülömböztető név");
			Errors.Add(MessageId.OpsInGblScope, "Parancsot csak függvényen belül lehet kiadni");
			Errors.Add(MessageId.NotExpected, "Nem várt kifejezés");
			Errors.Add(MessageId.TypeNotSpecified, "A típus nincs megadva");
			Errors.Add(MessageId.IdAlreadyDefined, "A megkülömböztető név már használva van");
			Errors.Add(MessageId.DeficientExpr, "Hiányos kifejezés");
			Errors.Add(MessageId.MustWhile, "Nincs lezárva a do-while ciklus");
			Errors.Add(MessageId.LoopWithoutDo, "A do-loop ciklusnak nincs kezdőtagja");
			Errors.Add(MessageId.StaticErr, "Csak típusok tagjai és osztályok lehetnek statikussak");
			Errors.Add(MessageId.CantOpApplied, "Ezt a műveletet nem lehet elvégezni '{0}' típusú értékkel");
			Errors.Add(MessageId.CallingNotFunc, "Csak fügvényeket lehet meghívni");
			Errors.Add(MessageId.MissingParam, "Hiányzik egy paraméter");
			Errors.Add(MessageId.NotVariable, "A(z) '{0}' egy típus, de változóként van használva");
			Errors.Add(MessageId.MissingThen, "A feltétel után then-nek kell következnie, ha egysoros a feltétel");
			Errors.Add(MessageId.AsmNotRId, "Nem lehet művelet az asm-ben használt hivatkozások");
			Errors.Add(MessageId.NotAllPathReturn, "A fügvény nem minden útvonalon tér vissza értékkel");
			Errors.Add(MessageId.AssignRValue, "A cél nem lehet r érték");
			Errors.Add(MessageId.LitType, "A tört szám nem lehet '{0}' típusú");
			Errors.Add(MessageId.UnknownCommand, "Ismeretlen parancs");
			Errors.Add(MessageId.ImplicitlyCast, "Típuskényszerítés szükséges a kovertáláshoz ('{0}' -> '{1}')");
			Errors.Add(MessageId.ForToDownToUntil, "Nincs megadva a ciklusváltozó végértéke");
			Errors.Add(MessageId.NoForVar, "Nincs megadva a ciklusváltozó");
			Errors.Add(MessageId.MoreForVar, "Csak egy ciklusváltozó lehet");
			Errors.Add(MessageId.NoForInitValue, "A ciklusváltozónak nincs kezdőértéke");
			Errors.Add(MessageId.NeedThenElse, "Then-nek és else-nek is kell lennie feltételben");
			Errors.Add(MessageId.WrongSettings, "Hibás beállítások: '{0}'");
			Errors.Add(MessageId.EntryNotFound, "Nem található a kezdő függvény ('{0}')");
			Errors.Add(MessageId.EntryNotSpecified, "Nincs megadva a kezdő függvénny");
			Errors.Add(MessageId.ImpExpGlbScope, "Az import és export résznek globálisnak kell lennie");
			Errors.Add(MessageId.CannotConvertConst, "A(z) '{0}' nem kovertálható '{1}' típusra");
			Errors.Add(MessageId.UnassignedVar, "A változó nem minden esetben kap értéket");
			Errors.Add(MessageId.AddressOfRValue, "R értéknek nem lehet lekérni a címét");
			Errors.Add(MessageId.MustBeGlobal, "A(z) {0} csak globális lehet");
			Errors.Add(MessageId.Untyped, "Nem lehet eldönteni az érték típusát");
			Errors.Add(MessageId.CannotDeclVar, "Nem lehet itt deklarálni a változót");
			Errors.Add(MessageId.CantOpApplied2, "Ezt a műveletet nem lehet elvégezni '{0}' és '{1}' típusú értékek között");
			Errors.Add(MessageId.PreprocError, "");
			Errors.Add(MessageId.UnknownType2, "Ismeretlen típus({0})");
			Errors.Add(MessageId.SameEnumValue, "Megegyezik az érték a(z) '{0}'-al");
			Errors.Add(MessageId.DefFuncParamVal, "A függvény paramétereknek nem lehet kezdőértékük");
			Errors.Add(MessageId.UnBreakCountinueable, "A break/continue csak akkor használható, ha egy ciklusban van");
			Errors.Add(MessageId.CaseWithoutSwitch, "A case/default csak switch után szerepelhet");
			Errors.Add(MessageId.CaseSystaxErr, "A case/default után a ':'-nak kell jeleznie a kifejezés végét");
			Errors.Add(MessageId.SwitchNoCaseDef, "A switch után case-nek vagy default-nak kell lennie");
			Errors.Add(MessageId.SwitchAlreadyHasDef, "A switch csak egy default cimkát tartalmazhat");
			Errors.Add(MessageId.EnumValOverflow, "Nincs több kiosztható érték");
			Errors.Add(MessageId.LabelAlreadyDefined, "Egy címke megegyező névvel már van deklarálva");
			Errors.Add(MessageId.UnknownLabel, "Ismeretlen címke");
			Errors.Add(MessageId.ConstOutOfRange, "Ebbe a típusba nem lehet ezt a számot tárolni");
			Errors.Add(MessageId.ReadOnly, "Ezt a változót csak olvasni lehet");
			Errors.Add(MessageId.CallConvErr, "Csak a függvényeknek lehet ilyen tulajdonságuk");
			Errors.Add(MessageId.Unnamed, "Nincs megadva a neve");
			Errors.Add(MessageId.CannotInherit, "A típus örökölhető");
			Errors.Add(MessageId.TypeCannotBeSpecified, "Típus után nem lehet változót deklarálni");
			Errors.Add(MessageId.NoConstructor, "Ennek a típusnak nincs publikus konstruktora");
			Errors.Add(MessageId.CantDeclare, "Nem lehet a típus nevével azonos tagot deklarálni");
			Errors.Add(MessageId.Static, "A struktúra tagja statikus");
			Errors.Add(MessageId.NonStatic, "A struktúra tagja nem statikus");
			Errors.Add(MessageId.ExternNonMSCoff, "Extern blokk csak MS Coff típusú assembly-be lehet");
			Errors.Add(MessageId.ModParamsNotAllowed, "A paraméterek nincsenek engedélyezve");
			Errors.Add(MessageId.FuncCannotHaveInnerScope, "A extern és import-hoz tartózó függvényeknek nem lehet tartalmuk");
			Errors.Add(MessageId.CannotGetSize, "Nem lehet ennek az identifiernek lekérdezni a méretét");
			Errors.Add(MessageId.MacroWithoutValue, "Ennek a makrónak nincs értéke");
			Errors.Add(MessageId.VarFuncRetType, "Nem lehet ilyen típusú a függvény visszatérési értéke");
			Errors.Add(MessageId.NonStaticInStaticClass, "Nem lehet definiálva egy statikus osztályban nem statikus tag");
			Errors.Add(MessageId.SealedErr, "Csak típusok tagjai és osztályok lehetnek véglegesek");
			Errors.Add(MessageId.StaticSealed, "Statikus osztályok nem lehetnek véglegesek");
			Errors.Add(MessageId.CannotInheritStatic, "Statikus osztályok nem örökölhetők");
			Errors.Add(MessageId.CannotInheritSealed, "Végleges osztályok nem örökölhetők");
			Errors.Add(MessageId.NoParamLessConstructor, "Az örökölt osztálynak nincs paraméter nélküli konstruktora");
			Errors.Add(MessageId.HasntGotMembers, "Ennek a típusnak({0}) nem lehetnek tagjai");
            Errors.Add(MessageId.CycleInStructs, "Nem lehet ilyen típus, mert végtelen ciklust hoz létre");
			Errors.Add(MessageId.MustBeUnnamed, "Ha az első változó el van nevezve, akkor a többinek is kell adni nevet");
			Errors.Add(MessageId.UnassignedVar2, "A változó({0}) nem minden esetben kap értéket");
            Errors.Add(MessageId.CannotBeThisType, "A változók nem lehetnek ilyen típusúak");
			Errors.Add(MessageId.MustBeNamed, "Ezt a változót el kell nevezni");
            Errors.Add(MessageId.MustHaveInitVal, "Ennek a változónak kell kezdőértéket adni");
			Errors.Add(MessageId.FileDoesntExists, "A fájl nem létezik");
			Errors.Add(MessageId.CantReadFile, "A fájl olvasása sikertelen");
			
			// Warnings
			Errors.Add(MessageId.EmptyScope, "Nincs hozzá tartozó kód megadva");
			Errors.Add(MessageId.CoreCountWarning, "A fordítás egy szálon fut");
			Errors.Add(MessageId.AssignSameVar, "Értékadás ugyanarra a változóra");
			Errors.Add(MessageId.VarAssignWoUsing, "A váltózó előző értéke nincs használva");
			Errors.Add(MessageId.UnreacheableCode, "Semmilyen útvonalon nem jut el ide a program");
			Errors.Add(MessageId.UnusedId, "A megkülönböztető név nincs használva");
			Errors.Add(MessageId.CastToSameType, "A típuskényszerítés megegyező típusra");
			Errors.Add(MessageId.CmpSameVariable, "Azonos változók közötti összehasonlítás");
			Errors.Add(MessageId.PreprocWarning, "");

			// Infos
			Errors.Add(MessageId.PreprocInfo, "");
		}

		public static string GetMessageDescription(MessageId Message, params string[] Params)
		{
			if (Message == MessageId.NoMessage)
				throw new Exception("ERROR");

			var ErrStr = Errors[Message];
			return String.Format(ErrStr, Params);
		}

        public Message(MessageId msg, PString Extra, params string[] Params)
        {
			Severity = (MessageSeverity)((int)msg / 1000 - 1);
            Description = GetMessageDescription(msg, Params);
            var ErrId = Severity.ToString() + " " + ((int)msg).ToString();

            if (Extra != null)
            {
                var PosStr = Extra.Line + "," + Extra.Char + "," + Extra.Length;
                Description = ErrId + "(" + PosStr + "): " + Description + ": " + Extra.String;
            }
            else
            {
                Description = ErrId + ": " + Description;
            }

            Description += ".";
        }

        public override string ToString()
        {
            return Description;
        }

        public void WriteToConsole()
        {
            Console.WriteLine(ToString());
        }
    }

    public class MessageCollector
    {
		public List<Message> Messages;
        public object LockObject;
		public bool CollectMessages = true;

		public MessageCollector(List<Message> Messages, object LockObject)
		{
			this.Messages = Messages;
			this.LockObject = LockObject;
		}

		public MessageCollector(MessageCollector Collector)
		{
			this.Messages = Collector.Messages;
			this.LockObject = Collector.LockObject;
		}

		public void Add(Message Message)
		{
			if (!CollectMessages) return;
			lock (LockObject) Messages.Add(Message);
		}

        public void Add(MessageId MessageId, PString Extra, params string[] Params)
        {
			Add(new Message(MessageId, Extra, Params));
        }

        public void Add(MessageId MessageId, String Extra, params string[] Params)
        {
            Add(MessageId, new PString(Extra), Params);
        }

        public void Add(MessageId MessageId)
        {
            Add(MessageId, (PString)null);
        }

        public void Add(MessageCollector Messages)
        {
			foreach (var e in Messages.Messages)
                Add(e);
        }

        public void WriteToConsole()
        {
			foreach (var e in Messages)
                e.WriteToConsole();
        }
    }

	public enum ImageFormat
	{
		GUI,
		Console,
		AsDLL,
		DLL,
		MSCoff,
	}

	public abstract class Language
	{
		public ExprRecognizer ExprRecognizer;
		public CommRecognizer CommRecognizer;
		public InnerScopeRecognizer InnerScopeRecognizer;
		public VarDeclRecognizer VarDeclRecognizer;
		public TypeDeclRecognizer TypeDeclRecognizer;
		public DeclarationRecognizer DeclarationRecognizer;
		public CodeProcessor CodeProcessor;
		public GlobalScopeProcessor GlobalScopeProcessor;

		public ArgRecognizer ArgRecognizer;

		public void Init()
		{
			ArgRecognizer = ExprRecognizer.GetRecognizer<ArgRecognizer>();
		}
	}

	public class CompilerState
	{
		public MessageCollector Messages;
		public ImageFormat Format = ImageFormat.GUI;
		public Architecture Arch;
		public Language Language;

		public string Entry = "Main";
		public int TabSize = 4;
		int AutoLabelIndex = 0;

		public CompilerState(Architecture Arch, Language Language)
		{
			var Lst = new List<Message>();
			Messages = new MessageCollector(Lst, new Object());

			this.Arch = Arch;
			this.Language = Language;
		}

		public bool HasMainFunc
		{
			get
			{
				return Format == ImageFormat.Console ||
					   Format == ImageFormat.GUI ||
					   Format == ImageFormat.MSCoff;
			}
		}

		public void Reset()
		{
			AutoLabelIndex = 0;
		}

		public int NextLabelIndex
		{
			get
			{
				Interlocked.Increment(ref AutoLabelIndex);
				return AutoLabelIndex;
			}
		}

		public int GetIndent(string String)
		{
			if (String == null) return 0;

			var Ret = 0;
			for (var i = 0; i < String.Length; i++)
			{
				var c = String[i];
				if (c == '\t') Ret += TabSize - (Ret % TabSize);
				else if (c == ' ') Ret++;
				else break;
			}

			return Ret;
		}

		public int GetIndent(PString String)
		{
			if (String == null) return 0;
			else return GetIndent(String.String);
		}

		public bool ChkNotExpected(PString Line)
		{
			var Trm = Line.Trim();
			if (Trm.StrLen > 0)
			{
				Messages.Add(MessageId.NotExpected, Trm);
				return false;
			}

			return true;
		}
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The GNU General Public License (GPLv3)

Share

About the Author

Dávid Kocsis
Student
Hungary Hungary
I've been programming for 8 years. My first big project was a remake of a nice bomberman game called Dyna Blaster. When i was little i played a lot with it. Now i'm working on a new programming language and code generator.
I would like to work with someone, so feel free to contact me about it.

| Advertise | Privacy | Mobile
Web04 | 2.8.140922.1 | Last Updated 1 Jan 2013
Article Copyright 2011 by Dávid Kocsis
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid