Salih hocamın hazırladığı Hafıza yönetimi sınıfını biraz daha geliştirdim ve şu anki parser sisteminin alt yapısında kullanmaya başladım burada ona tekrardan teşekkür etmek isterim :)

Kodların şu anki hali aşağıdaki gibi. RIL sınıfı oluşturdum (Rhodeus Intermediate Language) yani Rhodeus Ara Dili. İçerisinde 2 tane MEM sınıfı var birisi verileri saklamak için diğeri ise operandları saklamak için içerisine verileri yazmak için de

	final void load(ubyte operand, ...){
		codes.load(operand);
		foreach(arg; _arguments) {
			if(arg == typeid(string) || arg == typeid(immutable(string)) || arg == typeid(const(string))){
				codes.load(memory.load(va_arg!string(_argptr)));
			}else if (arg == typeid(int) || arg == typeid(immutable(int)) || arg == typeid(const(int))) {
				codes.load(memory.load(va_arg!int(_argptr)));
			}else if (arg == typeid(float) || arg == typeid(immutable(float)) || arg == typeid(const(float))) {
				codes.load(memory.load(va_arg!float(_argptr)));
			}else if (arg == typeid(bool) || arg == typeid(immutable(bool)) || arg == typeid(const(bool))) {
				codes.load(memory.load(va_arg!bool(_argptr)));
			}else assert(0, "invalid type " ~ arg.toString() );
		}
	}

Kodlarını yazdım burada D dilinin vararg özelliğini kullandım. Bu sayede runtime olarak parametreleri kontrol edebiliyorum ve sınırsız sayıda veri gönderebiliyorum Template de kullanabilirdim ama ilk defa gördüğüm bir özellik ve gerçekten çok hoşuma gitti :)

memory.load(IL_FLOAT, to!float(token.value));

Şeklinde memory ye yazıyorum ilk veri burada operand diğer veri float verisi yani operandın paramtresi oldu aslında burada uzun zamandır yapmak istediğim serbest parametreli sistemi uygulamış oldum.

class RIL{
	MEM memory;
	MEM codes;
	this(){
		memory = new MEM(256);
		codes = new MEM(256);
	}
	final void load(MEM www){
		codes.load(www.memory[0..www.freeLocated]);
	}
	final MEM newCache(int size = 256){
		codes = new MEM(size);
		return codes;
	}
	final void loadMEM(MEM old){
		codes = old;
	}
	final void load(ubyte operand, ...){
		codes.load(operand);
		foreach(arg; _arguments) {
			if(arg == typeid(string) || arg == typeid(immutable(string)) || arg == typeid(const(string))){
				codes.load(memory.load(va_arg!string(_argptr)));
			}else if (arg == typeid(int) || arg == typeid(immutable(int)) || arg == typeid(const(int))) {
				codes.load(memory.load(va_arg!int(_argptr)));
			}else if (arg == typeid(float) || arg == typeid(immutable(float)) || arg == typeid(const(float))) {
				codes.load(memory.load(va_arg!float(_argptr)));
			}else if (arg == typeid(bool) || arg == typeid(immutable(bool)) || arg == typeid(const(bool))) {
				codes.load(memory.load(va_arg!bool(_argptr)));
			}else assert(0, "invalid type " ~ arg.toString() );
		}
	}
	auto getString(int ptr){
		auto mem = &memory.memory[ptr];
		int len = *cast(int*) mem;
		mem += int.sizeof;
		return cast(string) (cast(char*) mem)[0..len];
	}
	auto getInt(int ptr){
		return *cast(int*) &memory.memory[ptr];
	}
	auto getFloat(int ptr){
		return *cast(float*) &memory.memory[ptr];
	}
	auto getBool(int ptr){
		return *cast(bool*) &memory.memory[ptr];
	}
	enum names = [
		IL_HASVALUE: "hasvalue?",
		IL_ADD: "add",
		IL_MUL: "mul",
		IL_DIV: "div",
		IL_SUB: "sub",
		IL_isLower:"<", IL_isLowerEquals:"<=",
		IL_isGreater:">", IL_isGreaterEquals:">=",
		IL_isEquals:"==", IL_isNotEquals:"!=",
		IL_isIn:"in",
		IL_LOR: "or",
		IL_LAND: "and",
		IL_jneset: "jneset",
		IL_jmpoint: "IL_jmpoint",
		IL_delpoint: "IL_delpoint"
	];

	string disAssembly(){
		string result;
		auto mbp = codes.memory.ptr;
		startp:
		switch(*mbp){
			case IL_PRINT:
				mbp++;
				result ~= "print %s\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_INT:
				mbp++;
				result ~= "load %s\n".format(getInt(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_STRING:
				mbp++;
				result ~= "load \"%s\"\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_NONE:
				mbp++;
				result ~= "load none\n";
				goto startp;
			case IL_BOOL:
				mbp++;
				result ~= "load %s\n".format(getBool(*mbp) ? "true": "false");
				mbp+=int.sizeof;
				goto startp;
			case IL_GETSUB:
				mbp++;
				result ~= "getsub %s\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_SETSUB:
				mbp++;
				result ~= "setsub %s\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_LOADVAR:
				mbp++;
				result ~= "loadvar %s\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_DEFINE:
				mbp++;
				result ~= "define %s\n".format(getString(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_INC:
				mbp++;
				result ~= "inc\n";
				goto startp;
			case IL_EQ:
				mbp++;
				result ~= "equal\n";
				goto startp;
			case IL_DEC:
				mbp++;
				result ~= "dec\n";
				goto startp;
			case IL_FINIT:
				mbp++;
				result ~= "function init\n";
				goto startp;
			case IL_FCALL:
				mbp++;
				result ~= "fcall (%s) \n".format(getInt(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_PUSH:
				mbp++;
				result ~= "push\n".format();
				goto startp;
			case IL_INDEX:
				mbp++;
				result ~= "index\n".format();
				goto startp;
			case IL_CMPLOAD:
				mbp++;
				result ~= "cmpload\n".format();
				goto startp;
			case IL_SLICE:
				mbp++;
				result ~= "slice\n".format();
				goto startp;
			case IL_INDEXEQ:
				mbp++;
				result ~= "index_equal\n".format();
				goto startp;
			case IL_SLICEEQ:
				mbp++;
				result ~= "slice_equal\n".format();
				goto startp;
			case IL_HLT:
				break;
			default:
				if(*mbp in names)
					result ~= "%s\n".format(names[*mbp]);
				else
					result ~= "undefined: %s\n".format(*mbp);
				mbp++;
				goto startp;
		}
		return result;
	}

}

class MEM {
public:
   ubyte[] memory;
   size_t freeLocated, memSize;

   immutable byteSize = 8;

   this(size_t minSize) {
       size_t isOverload = minSize % byteSize;
       memory = new ubyte[](minSize - isOverload);
       memSize = memory.length;
   }

   final auto load(inout int data) @property {
		auto ret = freeLocated;
       auto mem = cast(int*) malloc(data.sizeof);
       *mem = data;
		return ret;
   }
   final auto load(inout bool data) @property {
		auto ret = freeLocated;
       auto mem = cast(bool*) malloc(data.sizeof);
       *mem = data;
		return ret;
   }
   final auto load(inout float data) @property {
		auto ret = freeLocated;
       auto mem = cast(float*) malloc(data.sizeof);
       *mem = data;
		return ret;
   }
   final void load(inout ubyte data) @property {
       auto mem = cast(ubyte*) malloc(data.sizeof);
       *mem = data;
   }
   final void load(inout byte data) @property {
       auto mem = cast(byte*) malloc(data.sizeof);
       *mem = data;
   }
   final auto load(inout string data) @property {
		auto ret = freeLocated;
		auto mem = cast(char*) malloc(data.length + int.sizeof);
       *(cast(int*)mem) = cast(int) data.length;
       mem[int.sizeof..data.length+int.sizeof] = data;
		return ret;
   }

	final auto load(inout ubyte[] data) @property {
		auto ret = freeLocated;
		auto mem = cast(ubyte*) malloc(data.length);
       mem[0..data.length] = data;
		return ret;
   }

   private void extendMem() {
       memory.length += memSize * 2;
       memSize = memory.length;
   }
   final void memLoadBytes(inout ubyte[] data) @property {
       auto mem = cast(ubyte*) malloc(data.length);
       mem[0..data.length] = data;
   }
   final void* malloc(size_t size) {
       if(memSize  < freeLocated + size) {
           extendMem();
       }
       scope(exit) freeLocated += size;
       return &memory[freeLocated];
   }

   final void memWrite(inout(string) data) @property {
       auto mem = cast(char*) malloc(data.length);
       mem[0..data.length] = data;
   }
   final uint memReserveAddress() {
       scope(exit) malloc(int.sizeof);
       return freeLocated;
   }
   final void memSetAddress(uint adrl) {
       *cast(uint*) &memory[adrl] = memory.length;
   }

   override string toString() const{
       import std.range : repeat;
       string memImage  = "       DECIMAL MEMORY DUMP        ASCII  \n";
       memImage ~= format("%s\n", repeat('-', memImage.length)) ;

       for(int i; i < memory.length; i += byteSize) {
           auto row = memory[i..i + byteSize].dup;
           foreach(ref ubyte address; row) {
               if(address == 0){
                   address = 0xFF;
                   memImage ~= " ";
               }else if(address < 10) memImage ~= "   ";
               else if(address < 100) memImage ~= "  ";
               else if(address < 256) memImage ~= " ";
               memImage ~= to!string(address);
           }
           memImage ~= " ";
           foreach(c; row){
               memImage ~= c;
           }
           memImage ~= "\n";
       }
       writeln(format("%s>Total %s bytes<\n", repeat(' ', 10), memory.length));
       return memImage ~ format("%s>Total %s bytes<\n", repeat(' ', 10), memory.length);
   }
}

Kodları şu an tam olarak tamamlayamadım hala sıkıntılar var (VM kısmında) tamamladığım takdirde GITHUB da paylaşacağım hem o zaman tam çalışan halini görebilirsiniz :)

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Hocam haklısınız fakat şablonlara biraz yabancıyım tam uygulayamadım :/ Yardımcı olur musunuz?

   final auto load(T)(T data) @property {
		auto ret = freeLocated;
       auto mem = cast(T*) malloc(data.sizeof);
       *mem = data;
		return ret;
   }
   final auto load(T : T[])(T data) @property {
		auto ret = freeLocated;
		static if(typeid(T) == typeid(ubyte[])){
			auto mem = cast(ubyte*) malloc(data.length);
			mem[0..data.length] = data;
		}else{
			auto mem = cast(T*) malloc(data.length + T.sizeof);
			*(cast(typeof(data.length)*)mem) = data.length;
			mem[typeof(data.length).sizeof..data.length+typeof(data.length).sizeof] = data;
		}
		return ret;
   }

Kod bu ama hata veriyor array lar

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı:

Bunu öğrenmem iyi oldu :) Teşekkür ederim hocam.

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Çok güzel! :) Salih'in kodlarının kullanılması da çok güzel.

'names'i hiç değişmeyen değerlerden oluştuğu için bir eşleme tablosu (associative array) hazır değeri olarak düşünmüşsün.

Eşleme tablolarını hemen hemen hiçbir zaman enum olarak tanımlama. Onun etkisi, tablonun tanımını 'names'in kullanıldığı her yere sanki kod gibi yazılmış gibi eklemek oluyor. Yani, her 'names' dediğinde yepyeni bir tablo oluşturuluyor!

Onun yerine, 'names'i program başında tek kere kurup kullanmayı dene: Modül isimalanında bir değişken olsun. Onu bir static this() içinde ilkle (derlemeden gösteriyorum):

immutable string[int] names;

static this()
{
   // immutable değişkenler static this ile ilklenebilir
   names = [ /* ... */ ];
}

Kodda bazı MEM.load işlevlerinde olduğu gibi bazı tekrarlar var. Sayıları az olduğu için böyle de olur ama daha temiz olmasını istersen daha sonra load'u bir şablon olarak tanımlayabilirsin.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Sağolun hocam :) Hocam hata mesajı vermiyordu işte :D Baktığım zaman veriler hep yanlış yazılıyordu ve arraylı yere girmiyordu hiç :)

Hocam sadece tek bir hata alıyorum şu an oda şununla alakalı

Alıntı:

diyorum burada tabi string immutable(char) olduğu için mem de otomatik o değeri alıyor ve üzerine değer yazamıyorum burada immutableden kurtarmanın bir yolu var mı?

Teşekkürler :)

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

   final auto load(T)(T data)
       if (isArray!T &&
           !is(ElementType!T == ubyte))
		{
			auto ret = freeLocated;
			auto mem = cast(ElementType!T*) malloc(data.length + typeof(T.length).sizeof);
			*(cast(typeof(T.length)*)mem) = cast(typeof(T.length)) data.length;
			mem[typeof(T.length).sizeof..data.length+typeof(T.length).sizeof] = data;
			return ret;
		}

Hata ise:
Error 1 Error: cannot implicitly convert expression (data) of type string to const(dchar[]) C:\Users\TalhaZekeriya\Documents\GitHub\Script\source\MeMan.d 256
ilgili satır ise

mem[typeof(T.length).sizeof..data.length+typeof(T.length).sizeof] = data;

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Sorun ondan değilmiş :) ElementEncodingType kullandım ve sorun çözüldü dchar olarak görüyordu her nedense :)

   final auto load(T)(T data) if (isArray!T && !is(ElementType!T == ubyte)){
		auto ret = freeLocated;
		auto mem = cast(ElementEncodingType!(T)*) malloc(data.length + typeof(T.length).sizeof);
		*(cast(typeof(T.length)*)mem) = cast(typeof(T.length)) data.length;
		mem[typeof(T.length).sizeof..data.length+typeof(T.length).sizeof] = data;
		return ret;
	}

Hocam siz bir tanesiniz çok sağolun :)

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

module meman;

import std.conv, std.string, std.stdio;
import std.container;
import core.memory;
import std.format;
import std.traits;
import std.range;
import core.vararg;

enum : ubyte{
	IL_HLT,

	IL_PRINT,
	IL_STRING, IL_INT, IL_FLOAT, IL_NONE, IL_BOOL,

	IL_GETSUB, IL_SETSUB,

	IL_FCALL,


	IL_INDEX, IL_SLICE,
	IL_INDEXEQ, IL_SLICEEQ,

	IL_PUSH, IL_FINIT,

	IL_INC, IL_DEC,

	IL_ADD, IL_SUB, IL_MUL, IL_DIV, IL_MOD,
	IL_EQ, IL_MULEQ, IL_DIVEQ, IL_MODEQ, IL_ADDEQ, IL_SUBEQ,

	IL_LOADVAR, IL_DEFINE,

	IL_isLower, IL_isLowerEquals,
	IL_isGreater, IL_isGreaterEquals,
	IL_isEquals, IL_isNotEquals,
	IL_isIn,

	IL_jmpoint, IL_delpoint, IL_jneset,

	IL_LOR, IL_LAND,

	IL_CMPLOAD,

	IL_HASVALUE,

	IL_MATHSTART, IL_MATHEND
}

private string[ubyte] names;
static this(){
	names = [
		IL_HASVALUE: "hasvalue?", IL_ADD: "add", IL_MUL: "mul",
		IL_DIV: "div", IL_SUB: "sub", IL_isLower:"<",
		IL_isLowerEquals:"<=", IL_isGreater:">", IL_isGreaterEquals:">=",
		IL_isEquals:"==", IL_isNotEquals:"!=", IL_isIn:"in",
		IL_LOR: "or", IL_LAND: "and", IL_jneset: "jneset", IL_jmpoint: "IL_jmpoint",
		IL_delpoint: "IL_delpoint", IL_MATHSTART: "IL_MATHSTART", IL_MATHEND: "IL_MATHEND",
		IL_INDEXEQ: "IL_INDEXEQ", IL_NONE: "IL_NONE", IL_INC: "IL_INC",
		IL_EQ: "IL_EQ", IL_DEC: "IL_DEC", IL_FINIT: "IL_FINIT",
		IL_PUSH: "IL_PUSH", IL_INDEX: "IL_INDEX",
		IL_CMPLOAD: "IL_CMPLOAD", IL_SLICE: "IL_SLICE", IL_SLICEEQ: "IL_SLICEEQ",
		IL_DEFINE: "define", IL_LOADVAR: "lodvar", IL_SETSUB: "setsub",
		IL_GETSUB: "IL_GETSUB", IL_STRING: "load", IL_PRINT: "print",
		IL_INT: "load"
	];
}

class RIL{
	MEM memory;
	MEM codes;
	this(){
		memory = new MEM(256);
		codes = new MEM(256);
	}
	final void load(MEM www){
		codes.load(www.memory[0..www.freeLocated]);
	}
	final MEM newCache(int size = 256){
		codes = new MEM(size);
		return codes;
	}
	final void loadMEM(MEM old){
		codes = old;
	}
	final void load(ubyte operand, ...){
		codes.load(operand);
		foreach(arg; _arguments) {
			if(arg == typeid(string) || arg == typeid(immutable(string)) || arg == typeid(const(string))){
				codes.load(memory.load(va_arg!(char[])(_argptr)));
			}else if (arg == typeid(int) || arg == typeid(immutable(int)) || arg == typeid(const(int))) {
				codes.load(memory.load(va_arg!int(_argptr)));
			}else if (arg == typeid(float) || arg == typeid(immutable(float)) || arg == typeid(const(float))) {
				codes.load(memory.load(va_arg!float(_argptr)));
			}else if (arg == typeid(bool) || arg == typeid(immutable(bool)) || arg == typeid(const(bool))) {
				codes.load(memory.load(va_arg!bool(_argptr)));
			}else assert(0, "invalid type " ~ arg.toString() );
		}
	}
	final auto get(T)(int ptr) if (!isArray!T){
		return *cast(T*) &memory.memory[ptr];
	}
   final auto get(T)(int ptr) if (isArray!T){
		auto mem = &memory.memory[ptr];
		auto len = *cast(typeof(T.length)*) mem;
		mem += typeof(T.length).sizeof;
		return cast(T) (cast(ElementEncodingType!(T)*) mem)[0..len];
	}

	string disAssembly(){
		string result;
		auto mbp = codes.memory.ptr;
		startp:
		switch(*mbp){
			case IL_FCALL, IL_INT:
				mbp++;
				result ~= "%s (%s) \n".format(*mbp in names? names[*mbp] : to!string(*mbp), get!int(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_FLOAT:
				mbp++;
				result ~= "load %s\n".format(get!float(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_BOOL:
				mbp++;
				result ~= "load %s\n".format(get!bool(*cast(int*)mbp) ? "true": "false");
				mbp+=int.sizeof;
				goto startp;
			case IL_GETSUB, IL_SETSUB, IL_LOADVAR, IL_DEFINE, IL_STRING, IL_PRINT:
				mbp++;
				result ~= "%s %s\n".format(*mbp in names? names[*mbp] : to!string(*mbp), get!string(*cast(int*)mbp));
				mbp+=int.sizeof;
				goto startp;
			case IL_HLT:
				break;
			default:
				if(*mbp in names) result ~= "%s\n".format(names[*mbp]);
				else result ~= "undefined: %s\n".format(*mbp);
				mbp++;
				goto startp;
		}
		return result;
	}

}

class MEM {
public:
   ubyte[] memory;
   size_t freeLocated, memSize;

   immutable byteSize = 8;

   this(size_t minSize) {
       size_t isOverload = minSize % byteSize;
       memory = new ubyte[](minSize - isOverload);
       memSize = memory.length;
   }

	final auto load(T)(T data) if (!isArray!T){
		auto ret = freeLocated;
		auto mem = cast(T*) malloc(data.sizeof);
		*mem = data;
		return ret;
	}
   final auto load(T)(T data) if (isArray!T && !is(ElementType!T == ubyte)){
		auto ret = freeLocated;
		auto mem = cast(ElementEncodingType!(T)*) malloc(data.length + typeof(T.length).sizeof);
		*(cast(typeof(T.length)*)mem) = cast(typeof(T.length)) data.length;
		mem[typeof(T.length).sizeof..data.length+typeof(T.length).sizeof] = data;
		return ret;
	}
   final auto load(T)(T data) if (isArray!T && is(ElementType!T == ubyte)){
		auto ret = freeLocated;
		auto mem = cast(T*) malloc(data.length);
		mem[0..data.length] = data;
		return ret;
	}

   private void extendMem() {
       memory.length += memSize * 2;
       memSize = memory.length;
   }
   final void* malloc(size_t size) {
       if(memSize  < freeLocated + size) {
           extendMem();
       }
       scope(exit) freeLocated += size;
       return &memory[freeLocated];
   }

   final void memWrite(inout(string) data) @property {
       auto mem = cast(char*) malloc(data.length);
       mem[0..data.length] = data;
   }
   final uint memReserveAddress() {
       scope(exit) malloc(int.sizeof);
       return freeLocated;
   }
   final void memSetAddress(uint adrl) {
       *cast(uint*) &memory[adrl] = memory.length;
   }

   override string toString() const{
       import std.range : repeat;
       string memImage  = "       DECIMAL MEMORY DUMP        ASCII  \n";
       memImage ~= format("%s\n", repeat('-', memImage.length)) ;

       for(int i; i < memory.length; i += byteSize) {
           auto row = memory[i..i + byteSize].dup;
           foreach(ref ubyte address; row) {
               if(address == 0){
                   address = 0xFF;
                   memImage ~= " ";
               }else if(address < 10) memImage ~= "   ";
               else if(address < 100) memImage ~= "  ";
               else if(address < 256) memImage ~= " ";
               memImage ~= to!string(address);
           }
           memImage ~= " ";
           foreach(c; row){
               memImage ~= c;
           }
           memImage ~= "\n";
       }
       writeln(format("%s>Total %s bytes<\n", repeat(' ', 10), memory.length));
       return memImage ~ format("%s>Total %s bytes<\n", repeat(' ', 10), memory.length);
   }
}

Kodlar şu hale geldi :)

getString ve getInt gibi işlevleri kaldırdım şablonları kullandım :) Hem bu sayede her ne kadar şu an kullanmasam da her türü rahatlıkla yazıp okuyabilirim :)

	final void load(ubyte operand, ...){
		codes.load(operand);
		foreach(arg; _arguments) {
			if(arg == typeid(string) || arg == typeid(immutable(string)) || arg == typeid(const(string))){
				codes.load(memory.load(va_arg!(char[])(_argptr)));
			}else if (arg == typeid(int) || arg == typeid(immutable(int)) || arg == typeid(const(int))) {
				codes.load(memory.load(va_arg!int(_argptr)));
			}else if (arg == typeid(float) || arg == typeid(immutable(float)) || arg == typeid(const(float))) {
				codes.load(memory.load(va_arg!float(_argptr)));
			}else if (arg == typeid(bool) || arg == typeid(immutable(bool)) || arg == typeid(const(bool))) {
				codes.load(memory.load(va_arg!bool(_argptr)));
			}else assert(0, "invalid type " ~ arg.toString() );
		}
	}

Kısmı şimdilik böyle kalsın bu kullanım çok hoşuma gitti çünkü :) bunu sonradan şablonlara çeviririm :)

Zekeriya

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zekeriyadurmus):

Hocam hata mesajı da verilmez mi... :) Aşağıdaki yöntem yetiyor gibi:

class RIL{

   final auto load(T)(T data)
       if (!isArray!T)
   {
       int ret;
       writeln("Genel tanım");
       return ret;
   }

   final auto load(T)(T data)
       if (isArray!T &&
           !is(ElementType!T == ubyte))
   {
       int ret;
       writeln("Dizi tanımı");
       return ret;
   }

   final auto load(T)(T data)
       if (isArray!T &&
           is(ElementType!T == ubyte))
   {
       int ret;
       writeln("ubyte[] tanımı");
       return ret;
   }
}

void main()
{
   auto ril = new RIL();

   int i;
   ril.load(i);

   int[] dizi;
   ril.load(dizi);

   ubyte[] baytlar;
   ril.load(baytlar);
}

Çıktısı:
'
Genel tanım
Dizi tanımı
ubyte[] tanımı
'
Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (zekeriyadurmus):

D'nin çok yararlı ama çok şaşırtıcı özelliklerinden birisi o: Aralık olarak kullanıldıklarında string ve wstring'in bile eleman türü dchar'dır. Böylece .front dediğimizde otomatik olarak Unicode karakterini elde etmiş oluyoruz. Tabii perde arkasında dilimden birden fazla eleman çekilmiş olabiliyor.

Evet, char ve wchar gibi asıl dizi eleman türü istendiğinde ElementEncodingType oluyor...

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]