#!/usr/bin/env python
 
import math, glob, struct
from gimpfu import *
 
gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
 
V4_HEADER_SIZE = 108
COLOR_INFO_SIZE = 68
HEADER_OFF = 14
DATA_OFF_FIELD = 10
SIZE_OFF = 2
 
def strip_color_info(old_bmp_name, new_bmp_name=None):
	if new_bmp_name is None:
		new_bmp_name = old_bmp_name
	data = bytearray(open(old_bmp_name, "rb").read())
	header_size = struct.unpack("I", data[HEADER_OFF: HEADER_OFF + 4])[0]
	if header_size == 108:
		# Remove 68	 - the size for the extra data-chunk from both headers
		data[HEADER_OFF: HEADER_OFF + 4] = struct.pack("I", V4_HEADER_SIZE - COLOR_INFO_SIZE)
		data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4] = struct.pack("I",
			struct.unpack("I",data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4])[0] - COLOR_INFO_SIZE)
		# Offset image data:
		data[HEADER_OFF + header_size - COLOR_INFO_SIZE:] = data[HEADER_OFF + header_size:]
		data[SIZE_OFF: SIZE_OFF + 4] = struct.pack("I", len(data))
	with open(new_bmp_name, "wb") as output_file:
		output_file.write(data)
 
def batch_convert_indexed(pattern):
	for file in glob.glob(pattern):
		image = pdb.gimp_file_load(file, RUN_NONINTERACTIVE)
		drawable = pdb.gimp_image_get_active_layer(image)
		if pdb.gimp_image_base_type(image) != INDEXED:
			pdb.gimp_convert_indexed(image, NO_DITHER, MAKE_PALETTE, 256, False, True, "")
			pdb.gimp_file_save(image, drawable, file, file)
		pdb.gimp_image_delete(image)
		strip_color_info(file)
 
register(
        "batch_convert_indexed",
        "Batch process files and convert to indexed color palette",
        "Batch process files and convert to indexed color palette",
        "NightmareX1337",
        "NightmareX1337",
        "2016",
        "<Toolbox>/LF2 Tools/Batch Convert _Indexed...",
        None,
        [
                (PF_STRING, "pattern", "File Glob", "*.bmp")
        ],
        [],
        batch_convert_indexed)
 
main()

#!/usr/bin/env python
 
import math, glob, struct
from gimpfu import *
 
gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
 
V4_HEADER_SIZE = 108
COLOR_INFO_SIZE = 68
HEADER_OFF = 14
DATA_OFF_FIELD = 10
SIZE_OFF = 2
 
def strip_color_info(old_bmp_name, new_bmp_name=None):
	if new_bmp_name is None:
		new_bmp_name = old_bmp_name
	data = bytearray(open(old_bmp_name, "rb").read())
	header_size = struct.unpack("I", data[HEADER_OFF: HEADER_OFF + 4])[0]
	if header_size == 108:
		# Remove 68	 - the size for the extra data-chunk from both headers
		data[HEADER_OFF: HEADER_OFF + 4] = struct.pack("I", V4_HEADER_SIZE - COLOR_INFO_SIZE)
		data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4] = struct.pack("I",
			struct.unpack("I",data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4])[0] - COLOR_INFO_SIZE)
		# Offset image data:
		data[HEADER_OFF + header_size - COLOR_INFO_SIZE:] = data[HEADER_OFF + header_size:]
		data[SIZE_OFF: SIZE_OFF + 4] = struct.pack("I", len(data))
	with open(new_bmp_name, "wb") as output_file:
		output_file.write(data)
 
def batch_convert_rgb(pattern):
	for file in glob.glob(pattern):
		image = pdb.gimp_file_load(file, RUN_NONINTERACTIVE)
		drawable = pdb.gimp_image_get_active_layer(image)
		if pdb.gimp_image_base_type(image) != RGB:
			pdb.gimp_convert_rgb(image)
			pdb.gimp_file_save(image, drawable, file, file)
		pdb.gimp_image_delete(image)
		strip_color_info(file)
 
register(
		"batch_convert_rgb",
		"Batch process files and convert to RGB color palette",
		"Batch process files and convert to RGB color palette",
		"NightmareX1337",
		"NightmareX1337",
		"2016",
		"<Toolbox>/LF2 Tools/Batch Convert _RGB...",
		None,
		[
				(PF_STRING, "pattern", "File Glob", "*.bmp")
		],
		[],
		batch_convert_rgb)
 
main()

#!/usr/bin/env python
 
import math, glob, struct
from gimpfu import *
 
gettext.install("gimp20-python", gimp.locale_directory, unicode=True)
 
V4_HEADER_SIZE = 108
COLOR_INFO_SIZE = 68
HEADER_OFF = 14
DATA_OFF_FIELD = 10
SIZE_OFF = 2
 
def strip_color_info(old_bmp_name, new_bmp_name=None):
	if new_bmp_name is None:
		new_bmp_name = old_bmp_name
	data = bytearray(open(old_bmp_name, "rb").read())
	header_size = struct.unpack("I", data[HEADER_OFF: HEADER_OFF + 4])[0]
	if header_size == 108:
		# Remove 68	 - the size for the extra data-chunk from both headers
		data[HEADER_OFF: HEADER_OFF + 4] = struct.pack("I", V4_HEADER_SIZE - COLOR_INFO_SIZE)
		data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4] = struct.pack("I",
			struct.unpack("I",data[DATA_OFF_FIELD: DATA_OFF_FIELD + 4])[0] - COLOR_INFO_SIZE)
		# Offset image data:
		data[HEADER_OFF + header_size - COLOR_INFO_SIZE:] = data[HEADER_OFF + header_size:]
		data[SIZE_OFF: SIZE_OFF + 4] = struct.pack("I", len(data))
	with open(new_bmp_name, "wb") as output_file:
		output_file.write(data)
 
def batch_strip_color_space_info(pattern):
	for file in glob.glob(pattern):
		strip_color_info(file)
 
register(
        "batch_strip_color_space_info",
        "Batch process files and strip color space informations",
        "Batch process files and strip color space informations",
        "NightmareX1337",
        "NightmareX1337",
        "2016",
        "<Toolbox>/LF2 Tools/Batch _Strip Color Space Info...",
        None,
        [
                (PF_STRING, "pattern", "File Glob", "*.bmp")
        ],
        [],
        batch_strip_color_space_info)
 
main()

module drone.algorithm;
int[] quickSort(int[] data)
{
    //Implementation...
}

module program;
import drone.algorithm : quickSort; //import only the required function
import stdio = std.stdio; //renamed import can help not to pollute global scope
import std.algorithm; //just simply import
void main(string[] args)
{
    import std.conv : to; //scoped imports will only available in the function scope
    foreach(e; quickSort(args.map!(a => a.to!int)))
        stdio.writeln(e);
}

import std.stdio;
void main()
{
    int[] a; // a is a slice
    a = new int[5]; // allocate a dynamic array of integers that has at least 5 elements, and give me a slice to the first 5. Note that all data in D is default assigned, int's are defaulted to 0, so this array contains five 0's
    int[] b = a[0..2]; // This is a 'slicing' operation. b now refers to the first two elements of a. Note that D uses open interval for the upper limit, so a[2] is not included in b.
    int[] c = a[$-2..$]; // c refers to the last two elements of a ($ stands for length inside a slice or index operation).
    c[0] = 4; // this also assigns a[3]
    c[1] = 5; // this also assigns a[4]
    b[] = c[]; // assign the first two elements of a[] to the value from the last two elements (4, 5).
    writeln(a); // prints "[4, 5, 0, 4, 5]"
    int[5] d; // d is a fixed sized array, allocated on the stack
    b = d[0..2]; // slices can point at fixed sized arrays too!
}

import std.stdio : File;
import std.traits : isSomeString, isArray;
import std.range : isInfinite, isIterable, isInputRange;
import std.string : startsWith;
 
enum TokenState : ubyte
{
	none,
	xml,
	token,
	comment
}
 
enum TokenType : ubyte
{
	normal,
	xml,
	property,
}
 
struct Token(S) if(isSomeString!S)
{
	S str;
	size_t line, col;
	TokenType type;
	bool commentic;
 
	string toString()
	{
		return format(`"%s"[line: %d col: %d]  `, str, line, col);
	}
}
 
immutable string tokenHeads = ['<'], tokenEnds = ['>', ':'], tokenDelims = [' ', '\t'], 
	lineEnds = ['\n', '\r'];
enum char lineCommentChar = '#';
 
class ParserException : Exception
{
	this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null) @(safe, nogc) pure nothrow
	{
		super(msg, file, line, next);
	}
}
 
/// This function tokenizes LF2 data and returns a slice-array of strings. Returned slices point to the given string.
public Token!S[] parseData(S)(S data, bool includeComments = false) if(isSomeString!S)
{
	debug(LogFile)
	{
		File parserLog = File("parser.log", "wb");
		scope(exit) parserLog.close();
	}
	Token!S[] slices = new Token!S[4];
	slices.reserve(data.length / 5); // Pre-allocate an aprox memory we might need
 
	bool commentness = false;
	TokenState state = TokenState.none;
	size_t tokenStart = 0, tokenCol = 1, tokenLine = 1, line = 1, col = 1;
Lforeach:
	foreach(i, ch; data)
	{
	Lswitch:
		final switch(state)
		{
			case TokenState.none:
				if(lineEnds.canFind(ch))
				{
					commentness = false;
					break Lswitch;
				}
				else if(tokenDelims.canFind(ch))
				{
					break Lswitch;
				}
				else if(tokenHeads.canFind(ch)) // <
				{
					state = TokenState.xml;
					tokenStart = i;
					tokenCol = col;
					tokenLine = line;
				}
				else if(tokenEnds.canFind(ch)) // > :
				{
					throw new ParserException(format("Unexpected token ending delimeter: '%c' in line: %d; at col: %d", ch, line, col));
				}
				else if(ch == lineCommentChar) // #
				{
					commentness = true;
				    if(!includeComments)
						state = TokenState.comment;
				}
				else
				{
					state = TokenState.token;
					tokenStart = i;
					tokenCol = col;
					tokenLine = line;
				}
				break Lswitch;
			case TokenState.xml:
				if(lineEnds.canFind(ch))
				{
					throw new ParserException(format("Unexpected line ending in line %d; at col %d", line, col));
				}
				else if(tokenDelims.canFind(ch))
				{
					throw new ParserException(format("Unexpected token delimeter in line %d; at col %d", line, col));
				}
				else if(tokenHeads.canFind(ch)) // <
				{
					throw new ParserException(format("Unexpected token beginning delimeter '%c' in line %d; at col %d", ch, line, col));
				}
				else if(tokenEnds[0] == ch) // >
				{
					slices ~= Token!S(data[tokenStart .. i + 1], tokenLine, tokenCol, TokenType.xml, commentness);
					state = TokenState.none;
				}
				else if(tokenEnds[1] == ch) // :
				{
					throw new ParserException(format("Unexpected token ending delimeter '%c' in line %d; at col %d", ch, line, col));
				}
				else if(ch == lineCommentChar) // #
				{
					commentness = true;
					if(!includeComments)
						throw new ParserException(format("Unexpected comment char '%c' in line %d; at col %d", ch, line, col));
				}
				break Lswitch;
			case TokenState.token:
				if(lineEnds.canFind(ch))
				{
					slices ~= Token!S(data[tokenStart .. i], tokenLine, tokenCol, TokenType.normal, commentness);
					state = TokenState.none;
					commentness = false;
				}
				else if(tokenDelims.canFind(ch))
				{
					slices ~= Token!S(data[tokenStart .. i], tokenLine, tokenCol, TokenType.normal, commentness);
					state = TokenState.none;
				}
				else if(tokenHeads.canFind(ch)) // <
				{
					slices ~= Token!S(data[tokenStart .. i], tokenLine, tokenCol, TokenType.normal, commentness);
					state = TokenState.xml;
					tokenStart = i;
				}
				else if(ch == tokenEnds[0]) // >
				{
					throw new ParserException(format("Unexpected token ending delimeter '%c' in line %d; at col %d", ch, line, col));
				}
				else if(ch == tokenEnds[1]) // :
				{
					slices ~= Token!S(data[tokenStart .. i + 1], tokenLine, tokenCol, TokenType.property, commentness);
					state = TokenState.none;
				}
				else if(ch == lineCommentChar) // #
				{
					commentness = true;
					if(!includeComments)
					{
						slices ~= Token!S(data[tokenStart .. i + 1], tokenLine, tokenCol, TokenType.normal, commentness);
						state = TokenState.comment;
					}
				}
				break Lswitch;
			case TokenState.comment:
				if(lineEnds.canFind(ch))
				{
					commentness = true;
					state = TokenState.none;
				}
				break Lswitch;
		}
		if(ch == '\n')
		{
			line++;
			col = 1;
		}
		else
			col++;
	}
	switch(state)
	{
		case TokenState.token:
			slices ~= Token!S(data[tokenStart .. $], tokenLine, tokenCol, TokenType.normal, commentness);
			break;
		case TokenState.xml:
			throw new ParserException(format("Reached end of file unexpectedly while parsing token \"%s\" in line %d; at col %d", data[tokenStart .. $], line, col));
		default:
			break;
	}
	debug(LogFile)
	{
		size_t ln = 1;
		foreach(t; slices)
		{
			if(ln < t.line)
			{
				parserLog.write("\r\n", t.toString);
				ln = t.line;
			}
			else
				parserLog.write(t.toString);
		}
		parserLog.writeln("\r\n");
		parserLog.close();
	}
 
	return slices;
}

void square(int x) { return x * x; }
void foo(void)
{
    int k = square(32);
    /* ... */
}

int factorial(int x)
{
    int result = x;
    while (--x)
        result *= x;
    return result;
}
void foo(void)
{
    int k = factorial(8);
    /* ... */
}

#include <stdio.h>
int euler1(int max)
{
    int i, res = 0;
    for (i = 1; i < max; i++)
    {
        if ((i % 3) == 0 || (i % 5) == 0)
            res += i;
    }
    return res;
}
int main()
{
    int r10 = euler1(10);
    int r1000 = euler1(1000);
    printf("%d %d\n", r10, r1000);
    return 0;
}

int euler1(int max)
{
    int i, res = 0;
    for (i = 1; i < max; i++)
    {
        if ((i % 3) == 0 || (i % 5) == 0)
            res += i;
    }
    return res;
}
int main()
{
    int r10 = euler1(10);
    int r1000 = euler1(1000);
    printf("%d %d\n", r10, r1000);
    return 0;
}

static int r10 = euler1(10);
static int r1000 = euler1(1000);

D6euler14mainFZi3r10i:
    .long 23
.globl _D6euler14mainFZi5r1000i
    .align 4
    .type _D6euler14mainFZi5r1000i, @ object
    .size _D6euler14mainFZi5r1000i, 4
_D6euler14mainFZi5r1000i:
    .long 233168
    .section .rodata
.LC0:
    .string "%d %d\n"
    .text
    .globl _Dmain
    .type _Dmain, @ function
_Dmain:
.LFB3:
    pushq %rbp
.LCFI3:
    movq %rsp, %rbp
.LCFI4:
    movl _D6euler14mainFZi5r1000i(%rip), %edx
    movl _D6euler14mainFZi3r10i(%rip), %esi
    movl $.LC0, %edi
    movl $0, %eax
    call printf
    movl $0, %eax
    leave
    ret

T[] quickSort(T)(T[] array) //template function with type argument T
{
    //implementation...
}
struct RefCounted(T : struct)
{
    T* data;
    size_t rc = 0;
    void inc() { rc++; }
    void dec()
    {
        rc--;
        if(rc <= 0)
            destroy(*data);
    }
    //...
}

import std.stdio;
import std.traits;
import std.conv, std.algorithm, std.array, std.string;
import std.datetime;
 
public struct XmlIgnore { public bool ignore = true; }
 
public struct ComplexTestStruct {
@(XmlIgnore(false))
  int myint;
@(XmlIgnore(true))
  double precision;
@(XmlIgnore)
  Duration thetime;
  bool truth;
  string[string] properties
}
 
void main()
{
    auto data = ComplexTestStruct(50, 0.4, dur!"msecs"(100), true, ["one":"first", "two":"second"]);
    writeXml(data);
}
 
public void writeXml(T)(T obj, int indentLevel = 0, string name = null)
{
	writeIndented(indentLevel, "<", name == null ? T.stringof : name, ">\n");
	foreach(mem; FieldNameTuple!T)
	{
		const string mix = "obj." ~ mem;
		static if(!hasUDA!(mixin(mix), XmlIgnore) || (!hasUDA!(mixin(mix), XmlIgnore(true))))
		{
			const string typeStr = typeof(mixin(mix)).stringof;
			auto var = mixin(mix);
			static if(__traits(isScalar, var))
			{
				writeIndented(indentLevel + 1, "<", mem, ">", var, "</", mem, ">\n");
			}
			else static if(__traits(isAssociativeArray, var))
			{
				writeIndented(indentLevel + 1, "<", mem, ">\n");
				foreach(key, val; var)
					writeIndented(indentLevel + 2, "<", key, ">", val, "</", key, ">\n");
				writeIndented(indentLevel + 1, "</", mem, ">\n");
			}
			else static if(isArray!(typeof(var)) && !isSomeString!(typeof(var)))
			{
				const string arrayElementTypeStr = typeof(var[0]).stringof;
				static if(isBuiltinType!(typeof(var[0])))
				{
					//writeln(arrayElementTypeStr);
					writeIndented(indentLevel + 1, "<", mem, ">\n");
					foreach(val; var)
						writeIndented(indentLevel + 2, "<", arrayElementTypeStr, ">", val, "</", arrayElementTypeStr, ">\n");
					writeIndented(indentLevel + 1, "</", mem, ">\n");
				}
				else
				{
					//writeln(arrayElementTypeStr);
					writeIndented(indentLevel + 1, "<", mem, ">\n");
					foreach(val; var)
						writeXml(val, indentLevel + 2);
					writeIndented(indentLevel + 1, "</", mem, ">\n");
				}
			}
			else static if(is(typeof(var) == struct) || is(typeof(var) == class) || is(typeof(var) == interface))
			{
				writeXml(var, indentLevel + 1, mem);
			}
			else if(__traits(compiles, to!string(var)))
			{
				//writeln(typeStr);
				writeIndented(indentLevel + 1, "<", mem, ">", to!string(var), "</", mem, ">\n");
			}
			else
			{
				//writeln(typeStr);
				writeIndented(indentLevel + 1, "<", mem, ">", var, "</", mem, ">\n");
			}
		}
	}
	writeIndented(indentLevel, "</", name == null ? T.stringof : name, ">\n");
}
 
private void writeIndented(T...)(int level, T text)
{
	makeIndent(level);
	write(text);
}
 
private void makeIndent(int level)
{
	for(int i = 0; i < level; i++)
		write("  ");
}