Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

add samples

  • Loading branch information...
commit e94b273a675f6c2d0d94acc094067fb9adc42f90 1 parent bb60751
@WalterBright WalterBright authored
View
50 samples/all.sh
@@ -0,0 +1,50 @@
+
+# Little shell script to compile, link, and run all the samples.
+# Use dmd2\windows\bin\shell.exe to execute.
+
+DMD=..\..\windows\bin\dmd
+DFLAGS=
+CLEAN=clean.bat
+
+
+
+#~ $(DMD) chello $(DFLAGS) # which compilation flags?
+#~ chello
+
+$(DMD) d2html $(DFLAGS)
+d2html d2html.d
+
+$(DMD) dhry $(DFLAGS)
+dhry
+
+$(DMD) hello $(DFLAGS)
+hello
+
+#~ $(DMD) htmlget $(DFLAGS) # broken
+
+#~ $(DMD) listener $(DFLAGS) # broken
+
+
+$(DMD) pi $(DFLAGS)
+pi 1000
+
+$(DMD) sieve $(DFLAGS)
+sieve
+
+$(DMD) wc $(DFLAGS)
+wc wc.d
+
+$(DMD) wc2 $(DFLAGS)
+wc2 wc2.d
+
+$(DMD) winsamp gdi32.lib winsamp.def
+winsamp
+
+$(CLEAN)
+
+#~ broken:
+# COM client/server example
+#~ $(DMD) -c dserver -release $(DFLAGS)
+#~ $(DMD) -c chello $(DFLAGS)
+#~ $(DMD) dserver.obj chello.obj uuid.lib ole32.lib advapi32.lib kernel32.lib user32.lib dserver.def -L/map
+#~ $(DMD) dclient $(DFLAGS) ole32.lib uuid.lib
View
1  samples/build.bat
@@ -0,0 +1 @@
+..\..\windows\bin\shell all.sh
View
124 samples/chello.d
@@ -0,0 +1,124 @@
+
+/* Server for IHello
+ * Heavily modified from:
+ */
+/*
+ * SELFREG.CPP
+ * Server Self-Registrtation Utility, Chapter 5
+ *
+ * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Microsoft
+ * Internet : kraigb@microsoft.com
+ * Compuserve: >INTERNET:kraigb@microsoft.com
+ */
+
+// From an example from "Inside OLE" Copyright Microsoft
+
+import std.c.stdio;
+import std.c.stdlib;
+import std.string;
+import std.c.windows.windows;
+import std.c.windows.com;
+
+GUID CLSID_Hello = { 0x30421140, 0, 0, [0xC0, 0, 0, 0, 0, 0, 0, 0x46] };
+GUID IID_IHello = { 0x00421140, 0, 0, [0xC0, 0, 0, 0, 0, 0, 0, 0x46] };
+
+interface IHello : IUnknown
+{
+ extern (Windows) :
+ int Print();
+}
+
+// Type for an object-destroyed callback
+alias void (*PFNDESTROYED)();
+
+/*
+ * The class definition for an object that singly implements
+ * IHello in D.
+ */
+class CHello : ComObject, IHello
+{
+protected:
+ IUnknown m_pUnkOuter; // Controlling unknown
+
+ PFNDESTROYED m_pfnDestroy; // To call on closure
+
+ /*
+ * pUnkOuter LPUNKNOWN of a controlling unknown.
+ * pfnDestroy PFNDESTROYED to call when an object
+ * is destroyed.
+ */
+ public this(IUnknown pUnkOuter, PFNDESTROYED pfnDestroy)
+ {
+ m_pUnkOuter = pUnkOuter;
+ m_pfnDestroy = pfnDestroy;
+ }
+
+ ~this()
+ {
+ MessageBoxA(null, "CHello.~this()", null, MB_OK);
+ }
+
+ extern (Windows) :
+ /*
+ * Performs any intialization of a CHello that's prone to failure
+ * that we also use internally before exposing the object outside.
+ * Return Value:
+ * BOOL true if the function is successful,
+ * false otherwise.
+ */
+
+public:
+ BOOL Init()
+ {
+ MessageBoxA(null, "CHello.Init()", null, MB_OK);
+ return true;
+ }
+
+public:
+ HRESULT QueryInterface(const (IID)*riid, LPVOID *ppv)
+ {
+ MessageBoxA(null, "CHello.QueryInterface()", null, MB_OK);
+
+ if (IID_IUnknown == *riid)
+ *ppv = cast(void*) cast(IUnknown) this;
+ else if (IID_IHello == *riid)
+ *ppv = cast(void*) cast(IHello) this;
+ else
+ {
+ *ppv = null;
+ return E_NOINTERFACE;
+ }
+
+ AddRef();
+ return NOERROR;
+ }
+
+ ULONG Release()
+ {
+ MessageBoxA(null, "CHello.Release()", null, MB_OK);
+
+ if (0 != --count)
+ return count;
+
+ /*
+ * Tell the housing that an object is going away so it can
+ * shut down if appropriate.
+ */
+ MessageBoxA(null, "CHello Destroy()", null, MB_OK);
+
+ if (m_pfnDestroy)
+ (*m_pfnDestroy)();
+
+ // delete this;
+ return 0;
+ }
+
+ // IHello members
+ HRESULT Print()
+ {
+ MessageBoxA(null, "CHello.Print()", null, MB_OK);
+ return NOERROR;
+ }
+}
View
5 samples/clean.bat
@@ -0,0 +1,5 @@
+@echo off
+setlocal EnableDelayedExpansion
+del *.obj
+del *.map
+del *.res
View
401 samples/d2html.d
@@ -0,0 +1,401 @@
+
+/*
+ * Copyright (c) 2001
+ * Pavel "EvilOne" Minayev
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Author makes no representations about
+ * the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ */
+
+import std.c.stdio;
+
+import std.conv;
+import std.string;
+import std.stream; // don't forget to link with stream.obj!
+
+// colors for syntax highlighting, default values are
+// my preferences in Microsoft Visual Studio editor
+class Colors
+{
+ static string keyword = "0000FF";
+ static string number = "008000";
+ static string astring = "000080";
+ static string comment = "808080";
+}
+
+const int tabsize = 4; // number of spaces in tab
+const char[24] symbols = "()[]{}.,;:=<>+-*/%&|^!~?";
+string[] keywords;
+
+// true if c is whitespace, false otherwise
+byte isspace(char c)
+{
+ return indexOf(whitespace, c) >= 0;
+}
+
+// true if c is a letter or an underscore, false otherwise
+byte isalpha(char c)
+{
+ // underscore doesn't differ from letters in D anyhow...
+ return c == '_' || indexOf(letters, c) >= 0;
+}
+
+// true if c is a decimal digit, false otherwise
+byte isdigit(char c)
+{
+ return indexOf(digits, c) >= 0;
+}
+
+// true if c is a hexadecimal digit, false otherwise
+byte ishexdigit(char c)
+{
+ return indexOf(hexdigits, c) >= 0;
+}
+
+// true if c is an octal digit, false otherwise
+byte isoctdigit(char c)
+{
+ return indexOf(octdigits, c) >= 0;
+}
+
+// true if c is legal D symbol other than above, false otherwise
+byte issymbol(char c)
+{
+ return indexOf(symbols, c) >= 0;
+}
+
+// true if token is a D keyword, false otherwise
+byte iskeyword(string token)
+{
+ foreach (index, key; keywords)
+ {
+ if (!cmp(keywords[index], token))
+ return true;
+ }
+
+ return false;
+}
+
+int main(string[] args)
+{
+ // need help?
+ if (args.length < 2 || args.length > 3)
+ {
+ printf("D to HTML converter\n"
+ "Usage: D2HTML <program>.d [<file>.htm]\n");
+ return 0;
+ }
+
+ // auto-name output file
+ if (args.length == 2)
+ args ~= args[1] ~ ".htm";
+
+ // load keywords
+ File kwd = new File("d2html.kwd");
+
+ while (!kwd.eof())
+ keywords ~= to!string(kwd.readLine());
+
+ kwd.close();
+
+ // open input and output files
+ File src = new File(args[1]), dst = new File;
+ dst.create(args[2]);
+
+ // write HTML header
+ dst.writeLine("<html><head><title>" ~ args[1] ~ "</title></head>");
+ dst.writeLine("<body color='#000000' bgcolor='#FFFFFF'><pre><code>");
+
+ // the main part is wrapped into try..catch block because
+ // when end of file is reached, an exception is raised;
+ // so we can omit any checks for EOF inside this block...
+ try
+ {
+ ulong linestart = 0; // for tabs
+ char c;
+ src.read(c);
+
+ while (true)
+ {
+ if (isspace(c)) // whitespace
+ {
+ do
+ {
+ if (c == 9)
+ {
+ // expand tabs to spaces
+ auto spaces = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ for (int i = 0; i < spaces; i++)
+ dst.writeString(" ");
+
+ linestart = src.position() - tabsize + 1;
+ }
+ else
+ {
+ // reset line start on newline
+ if (c == 10 || c == 13)
+ linestart = src.position() + 1;
+
+ dst.write(c);
+ }
+
+ src.read(c);
+ } while (isspace(c));
+ }
+ else if (isalpha(c)) // keyword or identifier
+ {
+ string token;
+
+ do
+ {
+ token ~= c;
+ src.read(c);
+ } while (isalpha(c) || isdigit(c));
+
+ if (iskeyword(token)) // keyword
+ dst.writeString("<font color='#" ~ Colors.keyword ~
+ "'>" ~ token ~ "</font>");
+ else // simple identifier
+ dst.writeString(token);
+ }
+ else if (c == '0') // binary, octal or hexadecimal number
+ {
+ dst.writeString("<font color='#" ~ Colors.number ~ "008000'>");
+ dst.write(c);
+ src.read(c);
+
+ if (c == 'X' || c == 'x') // hexadecimal
+ {
+ dst.write(c);
+ src.read(c);
+
+ while (ishexdigit(c))
+ dst.write(c);
+
+ // TODO: add support for hexadecimal floats
+ }
+ else if (c == 'B' || c == 'b') // binary
+ {
+ dst.write(c);
+ src.read(c);
+
+ while (c == '0' || c == '1')
+ dst.write(c);
+ }
+ else // octal
+ {
+ do
+ {
+ dst.write(c);
+ src.read(c);
+ } while (isoctdigit(c));
+ }
+
+ dst.writeString("</font>");
+ }
+ else if (c == '#') // hash
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ else if (c == '\\') // backward slash
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ else if (isdigit(c)) // decimal number
+ {
+ dst.writeString("<font color='#" ~ Colors.number ~ "'>");
+
+ // integral part
+ do
+ {
+ dst.write(c);
+ src.read(c);
+ } while (isdigit(c));
+
+ // fractional part
+ if (c == '.')
+ {
+ dst.write(c);
+ src.read(c);
+
+ while (isdigit(c))
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+
+ // scientific notation
+ if (c == 'E' || c == 'e')
+ {
+ dst.write(c);
+ src.read(c);
+
+ if (c == '+' || c == '-')
+ {
+ dst.write(c);
+ src.read(c);
+ }
+
+ while (isdigit(c))
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+
+ // suffices
+ while (c == 'U' || c == 'u' || c == 'L' ||
+ c == 'l' || c == 'F' || c == 'f')
+ {
+ dst.write(c);
+ src.read(c);
+ }
+
+ dst.writeString("</font>");
+ }
+ else if (c == '\'') // string without escape sequences
+ {
+ dst.writeString("<font color='#" ~ Colors.astring ~ "'>");
+
+ do
+ {
+ if (c == '<') // special symbol in HTML
+ dst.writeString("&lt;");
+ else
+ dst.write(c);
+
+ src.read(c);
+ } while (c != '\'');
+ dst.write(c);
+ src.read(c);
+ dst.writeString("</font>");
+ }
+ else if (c == 34) // string with escape sequences
+ {
+ dst.writeString("<font color='#" ~ Colors.astring ~ "'>");
+ char prev; // used to handle \" properly
+
+ do
+ {
+ if (c == '<') // special symbol in HTML
+ dst.writeString("&lt;");
+ else
+ dst.write(c);
+
+ prev = c;
+ src.read(c);
+ } while (!(c == 34 && prev != '\\')); // handle \"
+ dst.write(c);
+ src.read(c);
+ dst.writeString("</font>");
+ }
+ else if (issymbol(c)) // either operator or comment
+ {
+ if (c == '<') // special symbol in HTML
+ {
+ dst.writeString("&lt;");
+ src.read(c);
+ }
+ else if (c == '/') // could be a comment...
+ {
+ src.read(c);
+
+ if (c == '/') // single-line one
+ {
+ dst.writeString("<font color='#" ~ Colors.comment ~ "'>/");
+
+ while (c != 10)
+ {
+ if (c == '<') // special symbol in HTML
+ dst.writeString("&lt;");
+ else if (c == 9)
+ {
+ // expand tabs
+ auto spaces2 = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ for (int i2 = 0; i2 < spaces2; i2++)
+ dst.writeString(" ");
+
+ linestart = src.position() - tabsize + 1;
+ }
+ else
+ dst.write(c);
+
+ src.read(c);
+ }
+
+ dst.writeString("</font>");
+ }
+ else if (c == '*') // multi-line one
+ {
+ dst.writeString("<font color='#" ~ Colors.comment ~ "'>/");
+ char prev2;
+
+ do
+ {
+ if (c == '<') // special symbol in HTML
+ dst.writeString("&lt;");
+ else if (c == 9)
+ {
+ // expand tabs
+ auto spaces3 = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ for (int i3 = 0; i3 < spaces3; i3++)
+ dst.writeString(" ");
+
+ linestart = src.position() - tabsize + 1;
+ }
+ else
+ {
+ // reset line start on newline
+ if (c == 10 || c == 13)
+ linestart = src.position() + 1;
+
+ dst.write(c);
+ }
+
+ prev2 = c;
+ src.read(c);
+ } while (!(c == '/' && prev2 == '*'));
+ dst.write(c);
+ dst.writeString("</font>");
+ src.read(c);
+ }
+ else // just an operator
+ dst.write(cast(char) '/');
+ }
+ else // just an operator
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+ else
+ // whatever it is, it's not a valid D token
+ throw new Error("unrecognized token");
+ //~ break;
+ }
+ }
+
+ // if end of file is reached and we try to read something
+ // with typed read(), a ReadError is thrown; in our case,
+ // this means that job is successfully done
+ catch (Exception e)
+ {
+ // write HTML footer
+ dst.writeLine("</code></pre></body></html>");
+ }
+ return 0;
+}
View
465 samples/d2html.d.htm
@@ -0,0 +1,465 @@
+<html><head><title>d2html.d</title></head>
+<body color='#000000' bgcolor='#FFFFFF'><pre><code>
+
+<font color='#808080'>/*
+ * Copyright (c) 2001
+ * Pavel "EvilOne" Minayev
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Author makes no representations about
+ * the suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ */</font>
+
+<font color='#0000FF'>import</font> std.c.stdio;
+
+<font color='#0000FF'>import</font> std.conv;
+<font color='#0000FF'>import</font> std.<font color='#0000FF'>string</font>;
+<font color='#0000FF'>import</font> std.stream; <font color='#808080'>// don't forget to link with stream.obj!
+</font>
+
+<font color='#808080'>// colors for syntax highlighting, default values are
+</font>
+<font color='#808080'>// my preferences in Microsoft Visual Studio editor
+</font>
+<font color='#0000FF'>class</font> Colors
+{
+ <font color='#0000FF'>static</font> <font color='#0000FF'>string</font> keyword = <font color='#000080'>"0000FF"</font>;
+ <font color='#0000FF'>static</font> <font color='#0000FF'>string</font> number = <font color='#000080'>"008000"</font>;
+ <font color='#0000FF'>static</font> <font color='#0000FF'>string</font> astring = <font color='#000080'>"000080"</font>;
+ <font color='#0000FF'>static</font> <font color='#0000FF'>string</font> comment = <font color='#000080'>"808080"</font>;
+}
+
+<font color='#0000FF'>const</font> <font color='#0000FF'>int</font> tabsize = <font color='#008000'>4</font>; <font color='#808080'>// number of spaces in tab
+</font>
+<font color='#0000FF'>const</font> <font color='#0000FF'>char</font>[<font color='#008000'>24</font>] symbols = <font color='#000080'>"()[]{}.,;:=&lt;>+-*/%&|^!~?"</font>;
+<font color='#0000FF'>string</font>[] keywords;
+
+<font color='#808080'>// true if c is whitespace, false otherwise
+</font>
+<font color='#0000FF'>byte</font> isspace(<font color='#0000FF'>char</font> c)
+{
+ <font color='#0000FF'>return</font> indexOf(whitespace, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if c is a letter or an underscore, false otherwise
+</font>
+<font color='#0000FF'>byte</font> isalpha(<font color='#0000FF'>char</font> c)
+{
+ <font color='#808080'>// underscore doesn't differ from letters in D anyhow...
+</font>
+ <font color='#0000FF'>return</font> c == <font color='#000080'>'_'</font> || indexOf(letters, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if c is a decimal digit, false otherwise
+</font>
+<font color='#0000FF'>byte</font> isdigit(<font color='#0000FF'>char</font> c)
+{
+ <font color='#0000FF'>return</font> indexOf(digits, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if c is a hexadecimal digit, false otherwise
+</font>
+<font color='#0000FF'>byte</font> ishexdigit(<font color='#0000FF'>char</font> c)
+{
+ <font color='#0000FF'>return</font> indexOf(hexdigits, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if c is an octal digit, false otherwise
+</font>
+<font color='#0000FF'>byte</font> isoctdigit(<font color='#0000FF'>char</font> c)
+{
+ <font color='#0000FF'>return</font> indexOf(octdigits, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if c is legal D symbol other than above, false otherwise
+</font>
+<font color='#0000FF'>byte</font> issymbol(<font color='#0000FF'>char</font> c)
+{
+ <font color='#0000FF'>return</font> indexOf(symbols, c) >= <font color='#008000008000'>0;</font>
+}
+
+<font color='#808080'>// true if token is a D keyword, false otherwise
+</font>
+<font color='#0000FF'>byte</font> iskeyword(<font color='#0000FF'>string</font> token)
+{
+ <font color='#0000FF'>foreach</font> (index, key; keywords)
+ {
+ <font color='#0000FF'>if</font> (!cmp(keywords[index], token))
+ <font color='#0000FF'>return</font> <font color='#0000FF'>true</font>;
+ }
+
+ <font color='#0000FF'>return</font> <font color='#0000FF'>false</font>;
+}
+
+<font color='#0000FF'>int</font> main(<font color='#0000FF'>string</font>[] args)
+{
+ <font color='#808080'>// need help?
+</font>
+ <font color='#0000FF'>if</font> (args.length &lt; <font color='#008000'>2</font> || args.length > <font color='#008000'>3</font>)
+ {
+ printf(<font color='#000080'>"D to HTML converter\n"</font>
+ <font color='#000080'>"Usage: D2HTML &lt;program>.d [&lt;file>.htm]\n"</font>);
+ <font color='#0000FF'>return</font> <font color='#008000008000'>0;</font>
+ }
+
+ <font color='#808080'>// auto-name output file
+</font>
+ <font color='#0000FF'>if</font> (args.length == <font color='#008000'>2</font>)
+ args ~= args[<font color='#008000'>1</font>] ~ <font color='#000080'>".htm"</font>;
+
+ <font color='#808080'>// load keywords
+</font>
+ File kwd = <font color='#0000FF'>new</font> File(<font color='#000080'>"d2html.kwd"</font>);
+
+ <font color='#0000FF'>while</font> (!kwd.eof())
+ keywords ~= to!<font color='#0000FF'>string</font>(kwd.readLine());
+
+ kwd.close();
+
+ <font color='#808080'>// open input and output files
+</font>
+ File src = <font color='#0000FF'>new</font> File(args[<font color='#008000'>1</font>]), dst = <font color='#0000FF'>new</font> File;
+ dst.create(args[<font color='#008000'>2</font>]);
+
+ <font color='#808080'>// write HTML header
+</font>
+ dst.writeLine(<font color='#000080'>"&lt;html>&lt;head>&lt;title>"</font> ~ args[<font color='#008000'>1</font>] ~ <font color='#000080'>"&lt;/title>&lt;/head>"</font>);
+ dst.writeLine(<font color='#000080'>"&lt;body color='#000000' bgcolor='#FFFFFF'>&lt;pre>&lt;code>"</font>);
+
+ <font color='#808080'>// the main part is wrapped into try..catch block because
+</font>
+ <font color='#808080'>// when end of file is reached, an exception is raised;
+</font>
+ <font color='#808080'>// so we can omit any checks for EOF inside this block...
+</font>
+ <font color='#0000FF'>try</font>
+ {
+ <font color='#0000FF'>ulong</font> linestart = <font color='#008000008000'>0;</font> <font color='#808080'>// for tabs
+</font>
+ <font color='#0000FF'>char</font> c;
+ src.read(c);
+
+ <font color='#0000FF'>while</font> (<font color='#0000FF'>true</font>)
+ {
+ <font color='#0000FF'>if</font> (isspace(c)) <font color='#808080'>// whitespace
+</font>
+ {
+ <font color='#0000FF'>do</font>
+ {
+ <font color='#0000FF'>if</font> (c == <font color='#008000'>9</font>)
+ {
+ <font color='#808080'>// expand tabs to spaces
+</font>
+ <font color='#0000FF'>auto</font> spaces = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ <font color='#0000FF'>for</font> (<font color='#0000FF'>int</font> i = <font color='#008000008000'>0;</font> i &lt; spaces; i++)
+ dst.writeString(<font color='#000080'>" "</font>);
+
+ linestart = src.position() - tabsize + <font color='#008000'>1</font>;
+ }
+ <font color='#0000FF'>else</font>
+ {
+ <font color='#808080'>// reset line start on newline
+</font>
+ <font color='#0000FF'>if</font> (c == <font color='#008000'>10</font> || c == <font color='#008000'>13</font>)
+ linestart = src.position() + <font color='#008000'>1</font>;
+
+ dst.write(c);
+ }
+
+ src.read(c);
+ } <font color='#0000FF'>while</font> (isspace(c));
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (isalpha(c)) <font color='#808080'>// keyword or identifier
+</font>
+ {
+ <font color='#0000FF'>string</font> token;
+
+ <font color='#0000FF'>do</font>
+ {
+ token ~= c;
+ src.read(c);
+ } <font color='#0000FF'>while</font> (isalpha(c) || isdigit(c));
+
+ <font color='#0000FF'>if</font> (iskeyword(token)) <font color='#808080'>// keyword
+</font>
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.keyword ~
+ <font color='#000080'>"'>"</font> ~ token ~ <font color='#000080'>"&lt;/font>"</font>);
+ <font color='#0000FF'>else</font> <font color='#808080'>// simple identifier
+</font>
+ dst.writeString(token);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'0'</font>) <font color='#808080'>// binary, octal or hexadecimal number
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.number ~ <font color='#000080'>"008000'>"</font>);
+ dst.write(c);
+ src.read(c);
+
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'X'</font> || c == <font color='#000080'>'x'</font>) <font color='#808080'>// hexadecimal
+</font>
+ {
+ dst.write(c);
+ src.read(c);
+
+ <font color='#0000FF'>while</font> (ishexdigit(c))
+ dst.write(c);
+
+ <font color='#808080'>// TODO: add support for hexadecimal floats
+</font>
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'B'</font> || c == <font color='#000080'>'b'</font>) <font color='#808080'>// binary
+</font>
+ {
+ dst.write(c);
+ src.read(c);
+
+ <font color='#0000FF'>while</font> (c == <font color='#000080'>'0'</font> || c == <font color='#000080'>'1'</font>)
+ dst.write(c);
+ }
+ <font color='#0000FF'>else</font> <font color='#808080'>// octal
+</font>
+ {
+ <font color='#0000FF'>do</font>
+ {
+ dst.write(c);
+ src.read(c);
+ } <font color='#0000FF'>while</font> (isoctdigit(c));
+ }
+
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'#'</font>) <font color='#808080'>// hash
+</font>
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'\\'</font>) <font color='#808080'>// backward slash
+</font>
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (isdigit(c)) <font color='#808080'>// decimal number
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.number ~ <font color='#000080'>"'>"</font>);
+
+ <font color='#808080'>// integral part
+</font>
+ <font color='#0000FF'>do</font>
+ {
+ dst.write(c);
+ src.read(c);
+ } <font color='#0000FF'>while</font> (isdigit(c));
+
+ <font color='#808080'>// fractional part
+</font>
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'.'</font>)
+ {
+ dst.write(c);
+ src.read(c);
+
+ <font color='#0000FF'>while</font> (isdigit(c))
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+
+ <font color='#808080'>// scientific notation
+</font>
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'E'</font> || c == <font color='#000080'>'e'</font>)
+ {
+ dst.write(c);
+ src.read(c);
+
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'+'</font> || c == <font color='#000080'>'-'</font>)
+ {
+ dst.write(c);
+ src.read(c);
+ }
+
+ <font color='#0000FF'>while</font> (isdigit(c))
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+
+ <font color='#808080'>// suffices
+</font>
+ <font color='#0000FF'>while</font> (c == <font color='#000080'>'U'</font> || c == <font color='#000080'>'u'</font> || c == <font color='#000080'>'L'</font> ||
+ c == <font color='#000080'>'l'</font> || c == <font color='#000080'>'F'</font> || c == <font color='#000080'>'f'</font>)
+ {
+ dst.write(c);
+ src.read(c);
+ }
+
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'\'</font><font color='#000080'>') // string without escape sequences
+ {
+ dst.writeString("&lt;font color='</font>#<font color='#000080'>" ~ Colors.astring ~ "</font><font color='#000080'>'>");
+
+ do
+ {
+ if (c == '</font>&lt;<font color='#000080'>') // special symbol in HTML
+ dst.writeString("&lt;");
+ else
+ dst.write(c);
+
+ src.read(c);
+ } while (c != '</font>\<font color='#000080'>''</font>);
+ dst.write(c);
+ src.read(c);
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#008000'>34</font>) <font color='#808080'>// string with escape sequences
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.astring ~ <font color='#000080'>"'>"</font>);
+ <font color='#0000FF'>char</font> prev; <font color='#808080'>// used to handle \" properly
+</font>
+
+ <font color='#0000FF'>do</font>
+ {
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'&lt;'</font>) <font color='#808080'>// special symbol in HTML
+</font>
+ dst.writeString(<font color='#000080'>"&lt;"</font>);
+ <font color='#0000FF'>else</font>
+ dst.write(c);
+
+ prev = c;
+ src.read(c);
+ } <font color='#0000FF'>while</font> (!(c == <font color='#008000'>34</font> && prev != <font color='#000080'>'\\'</font>)); <font color='#808080'>// handle \"
+</font>
+ dst.write(c);
+ src.read(c);
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (issymbol(c)) <font color='#808080'>// either operator or comment
+</font>
+ {
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'&lt;'</font>) <font color='#808080'>// special symbol in HTML
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;"</font>);
+ src.read(c);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'/'</font>) <font color='#808080'>// could be a comment...
+</font>
+ {
+ src.read(c);
+
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'/'</font>) <font color='#808080'>// single-line one
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.comment ~ <font color='#000080'>"'>/"</font>);
+
+ <font color='#0000FF'>while</font> (c != <font color='#008000'>10</font>)
+ {
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'&lt;'</font>) <font color='#808080'>// special symbol in HTML
+</font>
+ dst.writeString(<font color='#000080'>"&lt;"</font>);
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#008000'>9</font>)
+ {
+ <font color='#808080'>// expand tabs
+</font>
+ <font color='#0000FF'>auto</font> spaces2 = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ <font color='#0000FF'>for</font> (<font color='#0000FF'>int</font> i2 = <font color='#008000008000'>0;</font> i2 &lt; spaces2; i2++)
+ dst.writeString(<font color='#000080'>" "</font>);
+
+ linestart = src.position() - tabsize + <font color='#008000'>1</font>;
+ }
+ <font color='#0000FF'>else</font>
+ dst.write(c);
+
+ src.read(c);
+ }
+
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#000080'>'*'</font>) <font color='#808080'>// multi-line one
+</font>
+ {
+ dst.writeString(<font color='#000080'>"&lt;font color='#"</font> ~ Colors.comment ~ <font color='#000080'>"'>/"</font>);
+ <font color='#0000FF'>char</font> prev2;
+
+ <font color='#0000FF'>do</font>
+ {
+ <font color='#0000FF'>if</font> (c == <font color='#000080'>'&lt;'</font>) <font color='#808080'>// special symbol in HTML
+</font>
+ dst.writeString(<font color='#000080'>"&lt;"</font>);
+ <font color='#0000FF'>else</font> <font color='#0000FF'>if</font> (c == <font color='#008000'>9</font>)
+ {
+ <font color='#808080'>// expand tabs
+</font>
+ <font color='#0000FF'>auto</font> spaces3 = tabsize -
+ (src.position() - linestart) % tabsize;
+
+ <font color='#0000FF'>for</font> (<font color='#0000FF'>int</font> i3 = <font color='#008000008000'>0;</font> i3 &lt; spaces3; i3++)
+ dst.writeString(<font color='#000080'>" "</font>);
+
+ linestart = src.position() - tabsize + <font color='#008000'>1</font>;
+ }
+ <font color='#0000FF'>else</font>
+ {
+ <font color='#808080'>// reset line start on newline
+</font>
+ <font color='#0000FF'>if</font> (c == <font color='#008000'>10</font> || c == <font color='#008000'>13</font>)
+ linestart = src.position() + <font color='#008000'>1</font>;
+
+ dst.write(c);
+ }
+
+ prev2 = c;
+ src.read(c);
+ } <font color='#0000FF'>while</font> (!(c == <font color='#000080'>'/'</font> && prev2 == <font color='#000080'>'*'</font>));
+ dst.write(c);
+ dst.writeString(<font color='#000080'>"&lt;/font>"</font>);
+ src.read(c);
+ }
+ <font color='#0000FF'>else</font> <font color='#808080'>// just an operator
+</font>
+ dst.write(<font color='#0000FF'>cast</font>(<font color='#0000FF'>char</font>) <font color='#000080'>'/'</font>);
+ }
+ <font color='#0000FF'>else</font> <font color='#808080'>// just an operator
+</font>
+ {
+ dst.write(c);
+ src.read(c);
+ }
+ }
+ <font color='#0000FF'>else</font>
+ <font color='#808080'>// whatever it is, it's not a valid D token
+</font>
+ <font color='#0000FF'>throw</font> <font color='#0000FF'>new</font> Error(<font color='#000080'>"unrecognized token"</font>);
+ <font color='#808080'>//~ break;
+</font>
+ }
+ }
+
+ <font color='#808080'>// if end of file is reached and we try to read something
+</font>
+ <font color='#808080'>// with typed read(), a ReadError is thrown; in our case,
+</font>
+ <font color='#808080'>// this means that job is successfully done
+</font>
+ <font color='#0000FF'>catch</font> (Exception e)
+ {
+ <font color='#808080'>// write HTML footer
+</font>
+ dst.writeLine(<font color='#000080'>"&lt;/code>&lt;/pre>&lt;/body>&lt;/html>"</font>);
+ }
+ <font color='#0000FF'>return</font> <font color='#008000008000'>0;</font>
+}
+</code></pre></body></html>
View
179 samples/d2html.kwd
@@ -0,0 +1,179 @@
+property
+abstract
+alias
+align
+asm
+assert
+auto
+body
+bool
+break
+byte
+case
+cast
+catch
+cdouble
+cent
+cfloat
+char
+class
+const
+continue
+creal
+dchar
+dstring
+debug
+default
+delegate
+delete
+deprecated
+do
+double
+else
+enum
+export
+extern
+false
+final
+finally
+float
+for
+foreach
+foreach_reverse
+function
+goto
+idouble
+if
+ifloat
+immutable
+import
+in
+inout
+int
+interface
+invariant
+ireal
+is
+lazy
+long
+macro
+mixin
+module
+new
+nothrow
+null
+out
+override
+package
+pragma
+private
+protected
+public
+pure
+real
+ref
+return
+scope
+shared
+short
+size_t
+static
+string
+struct
+super
+switch
+synchronized
+template
+this
+throw
+true
+try
+typedef
+typeid
+typeof
+ubyte
+ucent
+uint
+ulong
+union
+unittest
+ushort
+version
+void
+volatile
+wchar
+wstring
+while
+with
+__FILE__
+__LINE__
+__gshared
+__thread
+__traits
+const_cast
+dynamic_cast
+explicit
+friend
+inline
+mutable
+namespace
+operator
+register
+reinterpret_cast
+restrict
+signed
+sizeof
+static_cast
+typename
+unsigned
+using
+virtual
+int8_t
+uint8_t
+int16_t
+uint16_t
+int32_t
+uint32_t
+int64_t
+uint64_t
+int_least8_t
+uint_least8_t
+int_least16_t
+uint_least16_t
+int_least32_t
+uint_least32_t
+int_least64_t
+uint_least64_t
+int_fast8_t
+uint_fast8_t
+int_fast16_t
+uint_fast16_t
+int_fast32_t
+uint_fast32_t
+int_fast64_t
+uint_fast64_t
+intptr_t
+uintptr_t
+intmax_t
+uintmax_t
+wint_t
+wchar_t
+wctrans_t
+time_t
+and
+and_eq
+bitand
+bitor
+compl
+not
+not_eq
+or
+or_eq
+xor
+xor_eq
+wctype_tcomplex
+imaginary
+_Complex
+_Imaginary
+_Bool
+_Pragma
View
126 samples/dclient.d
@@ -0,0 +1,126 @@
+
+/* Client for IHello
+ * Heavily modified from:
+ */
+/*
+ * SELFREG.CPP
+ * Server Self-Registrtation Utility, Chapter 5
+ *
+ * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Microsoft
+ * Internet : kraigb@microsoft.com
+ * Compuserve: >INTERNET:kraigb@microsoft.com
+ */
+
+import std.c.stdio;
+import std.c.stdlib;
+import std.c.windows.windows;
+import std.c.windows.com;
+
+GUID CLSID_Hello = { 0x30421140, 0, 0, [0xC0, 0, 0, 0, 0, 0, 0, 0x46] };
+GUID IID_IHello = { 0x00421140, 0, 0, [0xC0, 0, 0, 0, 0, 0, 0, 0x46] };
+
+interface IHello : IUnknown
+{
+ extern (Windows) :
+ int Print();
+}
+
+int main()
+{
+ DWORD dwVer;
+ HRESULT hr;
+ IHello pIHello;
+
+ // Make sure COM is the right version
+ dwVer = CoBuildVersion();
+
+ if (rmm != HIWORD(dwVer))
+ {
+ printf("Incorrect OLE 2 version number\n");
+ return EXIT_FAILURE;
+ }
+
+ hr=CoInitialize(null); // Initialize OLE
+
+ if (FAILED(hr))
+ {
+ printf("OLE 2 failed to initialize\n");
+ return EXIT_FAILURE;
+ }
+
+ printf("OLE 2 initialized\n");
+
+ if (dll_regserver("dserver.dll", 1) == 0)
+ {
+ printf("server registered\n");
+ hr=CoCreateInstance(&CLSID_Hello, null, CLSCTX_ALL, &IID_IHello, &pIHello);
+
+ if (FAILED(hr))
+ {
+ printf("Failed to create object x%x\n", hr);
+ }
+ else
+ {
+ printf("Object created, calling IHello.Print(), IHello = %p\n", pIHello);
+
+ // fflush(stdout);
+ pIHello.Print();
+ pIHello.Release();
+ }
+
+ CoFreeUnusedLibraries();
+
+ if (dll_regserver("dserver.dll", 0))
+ printf("server unregister failed\n");
+ }
+ else
+ printf("server registration failed\n");
+
+ // Only call this if CoInitialize worked
+ CoUninitialize();
+ return EXIT_SUCCESS;
+}
+
+/**************************************
+ * Register/unregister a DLL server.
+ * Input:
+ * flag !=0: register
+ * ==0: unregister
+ * Returns:
+ * 0 success
+ * !=0 failure
+ */
+
+extern (Windows) alias HRESULT (*pfn_t)();
+
+int dll_regserver(const (char) *dllname, int flag)
+{
+ char *fn = flag ? cast(char*) "DllRegisterServer"
+ : cast(char*) "DllUnregisterServer";
+ int result = 1;
+ pfn_t pfn;
+ HINSTANCE hMod;
+
+ if (SUCCEEDED(CoInitialize(null)))
+ {
+ hMod=LoadLibraryA(dllname);
+ printf("hMod = %d\n", hMod);
+
+ if (hMod > cast(HINSTANCE) HINSTANCE_ERROR)
+ {
+ printf("LoadLibraryA() succeeded\n");
+ pfn = GetProcAddress(hMod, fn);
+ printf("pfn = %p, fn = '%s'\n", pfn, fn);
+
+ if (pfn && SUCCEEDED((*pfn)()))
+ result = 0;
+
+ CoFreeLibrary(hMod);
+ CoUninitialize();
+ }
+ }
+
+ return result;
+}
View
935 samples/dhry.d
@@ -0,0 +1,935 @@
+
+/*
+ *************************************************************************
+ *
+ * "DHRYSTONE" Benchmark Program
+ * -----------------------------
+ *
+ * Version: C, Version 2.1
+ *
+ * File: dhry.h (part 1 of 3)
+ *
+ * Date: May 25, 1988
+ *
+ * Author: Reinhold P. Weicker
+ * Siemens Nixdorf Inf. Syst.
+ * STM OS 32
+ * Otto-Hahn-Ring 6
+ * W-8000 Muenchen 83
+ * Germany
+ * Phone: [+49]-89-636-42436
+ * (8-17 Central European Time)
+ * UUCP: weicker@ztivax.uucp@unido.uucp
+ * Internet: weicker@ztivax.siemens.com
+ *
+ * Original Version (in Ada) published in
+ * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
+ * pp. 1013 - 1030, together with the statistics
+ * on which the distribution of statements etc. is based.
+ *
+ * In this C version, the following C library functions are
+ * used:
+ * - strcpy, strcmp (inside the measurement loop)
+ * - printf, scanf (outside the measurement loop)
+ *
+ * Collection of Results:
+ * Reinhold Weicker (address see above) and
+ *
+ * Rick Richardson
+ * PC Research. Inc.
+ * 94 Apple Orchard Drive
+ * Tinton Falls, NJ 07724
+ * Phone: (201) 834-1378 (9-17 EST)
+ * UUCP: ...!uunet!pcrat!rick
+ *
+ * Please send results to Rick Richardson and/or Reinhold Weicker.
+ * Complete information should be given on hardware and software
+ * used. Hardware information includes: Machine type, CPU, type and
+ * size of caches; for microprocessors: clock frequency, memory speed
+ * (number of wait states). Software information includes: Compiler
+ * (and runtime library) manufacturer and version, compilation
+ * switches, OS version. The Operating System version may give an
+ * indication about the compiler; Dhrystone itself performs no OS
+ * calls in the measurement loop.
+ *
+ * The complete output generated by the program should be mailed
+ * such that at least some checks for correctness can be made.
+ *
+ *************************************************************************
+ *
+ * History: This version C/2.1 has been made for two reasons:
+ *
+ * 1) There is an obvious need for a common C version of
+ * Dhrystone, since C is at present the most popular system
+ * programming language for the class of processors
+ * (microcomputers, minicomputers) where Dhrystone is used
+ * most. There should be, as far as possible, only one C
+ * version of Dhrystone such that results can be compared
+ * without restrictions. In the past, the C versions
+ * distributed by Rick Richardson (Version 1.1) and by
+ * Reinhold Weicker had small (though not significant)
+ * differences.
+ *
+ * 2) As far as it is possible without changes to the
+ * Dhrystone statistics, optimizing compilers should be
+ * prevented from removing significant statements.
+ *
+ * This C version has been developed in cooperation with
+ * Rick Richardson (Tinton Falls, NJ), it incorporates many
+ * ideas from the "Version 1.1" distributed previously by
+ * him over the UNIX network Usenet.
+ * I also thank Chaim Benedelac (National Semiconductor),
+ * David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
+ * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
+ * for their help with comments on earlier versions of the
+ * benchmark.
+ *
+ * Changes: In the initialization part, this version follows mostly
+ * Rick Richardson's version distributed via Usenet, not the
+ * version distributed earlier via floppy disk by Reinhold
+ * Weicker. As a concession to older compilers, names have
+ * been made unique within the first 8 characters. Inside the
+ * measurement loop, this version follows the version
+ * previously distributed by Reinhold Weicker.
+ *
+ * At several places in the benchmark, code has been added,
+ * but within the measurement loop only in branches that
+ * are not executed. The intention is that optimizing
+ * compilers should be prevented from moving code out of the
+ * measurement loop, or from removing code altogether. Since
+ * the statements that are executed within the measurement
+ * loop have NOT been changed, the numbers defining the
+ * "Dhrystone distribution" (distribution of statements,
+ * operand types and locality) still hold. Except for
+ * sophisticated optimizing compilers, execution times for
+ * this version should be the same as for previous versions.
+ *
+ * Since it has proven difficult to subtract the time for the
+ * measurement loop overhead in a correct way, the loop check
+ * has been made a part of the benchmark. This does have
+ * an impact - though a very minor one - on the distribution
+ * statistics which have been updated for this version.
+ *
+ * All changes within the measurement loop are described
+ * and discussed in the companion paper "Rationale for
+ * Dhrystone version 2".
+ *
+ * Because of the self-imposed limitation that the order and
+ * distribution of the executed statements should not be
+ * changed, there are still cases where optimizing compilers
+ * may not generate code for some statements. To a certain
+ * degree, this is unavoidable for small synthetic
+ * benchmarks. Users of the benchmark are advised to check
+ * code listings whether code is generated for all statements
+ * of Dhrystone.
+ *
+ * Version 2.1 is identical to version 2.0 distributed via
+ * the UNIX network Usenet in March 1988 except that it
+ * corrects some minor deficiencies that were found by users
+ * of version 2.0. The only change within the measurement
+ * loop is that a non-executed "else" part was added to the
+ * "if" statement in Func_3, and a non-executed "else" part
+ * removed from Proc_3.
+ *
+ *************************************************************************
+ *
+ * Defines: The following "Defines" are possible:
+ * -DROPT (default: Not defined)
+ * As an approximation to what an average C
+ * programmer might do, the "register" storage class
+ * is applied (if enabled by -DROPT)
+ * - for local variables, if they are used
+ * (dynamically) five or more times
+ * - for parameters if they are used (dynamically)
+ * six or more times
+ * Note that an optimal "register" strategy is
+ * compiler-dependent, and that "register"
+ * declarations do not necessarily lead to faster
+ * execution.
+ * -DNOSTRUCTASSIGN (default: Not defined)
+ * Define if the C compiler does not support
+ * assignment of structures.
+ * -DNOENUMS (default: Not defined)
+ * Define if the C compiler does not support
+ * enumeration types.
+ *
+ *************************************************************************
+ *
+ * Compilation model and measurement (IMPORTANT):
+ *
+ * This C version of Dhrystone consists of three files:
+ * - dhry.h (this file, containing global definitions and comments)
+ * - dhry_1.c (containing the code corresponding to Ada package Pack_1)
+ * - dhry_2.c (containing the code corresponding to Ada package Pack_2)
+ *
+ * The following "ground rules" apply for measurements:
+ * - Separate compilation
+ * - No procedure merging
+ * - Otherwise, compiler optimizations are allowed but should be
+ * indicated
+ * - Default results are those without register declarations
+ * See the companion paper "Rationale for Dhrystone Version 2" for a more
+ * detailed discussion of these ground rules.
+ *
+ * For 16-Bit processors (e.g. 80186, 80286), times for all compilation
+ * models ("small", "medium", "large" etc.) should be given if possible,
+ * together with a definition of these models for the compiler system
+ * used.
+ *
+ *************************************************************************
+ *
+ * Dhrystone (C version) statistics:
+ *
+ * [Comment from the first distribution, updated for version 2.
+ * Note that because of language differences, the numbers are slightly
+ * different from the Ada version.]
+ *
+ * The following program contains statements of a high level programming
+ * language (here: C) in a distribution considered representative:
+ *
+ * assignments 52 (51.0 %)
+ * control statements 33 (32.4 %)
+ * procedure, function calls 17 (16.7 %)
+ *
+ * 103 statements are dynamically executed. The program is balanced with
+ * respect to the three aspects:
+ *
+ * - statement type
+ * - operand type
+ * - operand locality
+ * operand global, local, parameter, or constant.
+ *
+ * The combination of these three aspects is balanced only approximately.
+ *
+ * 1. Statement Type:
+ * ----------------- number
+ *
+ * V1 = V2 9
+ * (incl. V1 = F(..)
+ * V = Constant 12
+ * Assignment, 7
+ * with array element
+ * Assignment, 6
+ * with record component
+ * --
+ * 34 34
+ *
+ * X = Y +|-|"&&"|"|" Z 5
+ * X = Y +|-|"==" Constant 6
+ * X = X +|- 1 3
+ * X = Y *|/ Z 2
+ * X = Expression, 1
+ * two operators
+ * X = Expression, 1
+ * three operators
+ * --
+ * 18 18
+ *
+ * if .... 14
+ * with "else" 7
+ * without "else" 7
+ * executed 3
+ * not executed 4
+ * for ... 7 | counted every time
+ * while ... 4 | the loop condition
+ * do ... while 1 | is evaluated
+ * switch ... 1
+ * break 1
+ * declaration with 1
+ * initialization
+ * --
+ * 34 34
+ *
+ * P (...) procedure call 11
+ * user procedure 10
+ * library procedure 1
+ * X = F (...)
+ * function call 6
+ * user function 5
+ * library function 1
+ * --
+ * 17 17
+ * ---
+ * 103
+ *
+ * The average number of parameters in procedure or function calls
+ * is 1.82 (not counting the function values as implicit parameters).
+ *
+ *
+ * 2. Operators
+ * ------------
+ * number approximate
+ * percentage
+ *
+ * Arithmetic 32 50.8
+ *
+ * + 21 33.3
+ * - 7 11.1
+ * * 3 4.8
+ * / (int div) 1 1.6
+ *
+ * Comparison 27 42.8
+ *
+ * == 9 14.3
+ * /= 4 6.3
+ * > 1 1.6
+ * < 3 4.8
+ * >= 1 1.6
+ * <= 9 14.3
+ *
+ * Logic 4 6.3
+ *
+ * && (AND-THEN) 1 1.6
+ * | (OR) 1 1.6
+ * ! (NOT) 2 3.2
+ *
+ * -- -----
+ * 63 100.1
+ *
+ *
+ * 3. Operand Type (counted once per operand reference):
+ * ---------------
+ * number approximate
+ * percentage
+ *
+ * Integer 175 72.3 %
+ * Character 45 18.6 %
+ * Pointer 12 5.0 %
+ * String30 6 2.5 %
+ * Array 2 0.8 %
+ * Record 2 0.8 %
+ * --- -------
+ * 242 100.0 %
+ *
+ * When there is an access path leading to the final operand (e.g. a
+ * record component), only the final data type on the access path is
+ * counted.
+ *
+ *
+ * 4. Operand Locality:
+ * -------------------
+ * number approximate
+ * percentage
+ *
+ * local variable 114 47.1 %
+ * global variable 22 9.1 %
+ * parameter 45 18.6 %
+ * value 23 9.5 %
+ * reference 22 9.1 %
+ * function result 6 2.5 %
+ * constant 55 22.7 %
+ * --- -------
+ * 242 100.0 %
+ *
+ *
+ * The program does not compute anything meaningful, but it is
+ * syntactically and semantically correct. All variables have a value
+ * assigned to them before they are used as a source operand.
+ *
+ * There has been no explicit effort to account for the effects of a
+ * cache, or to balance the use of long or short displacements for code
+ * or data.
+ *
+ *************************************************************************
+ */
+
+import std.c.stdio;
+import std.c.string;
+import std.c.stdlib;
+import std.string;
+
+/* Compiler and system dependent definitions: */
+
+const double Mic_secs_Per_Second = 1000000.0;
+
+/* Berkeley UNIX C returns process times in seconds/HZ */
+
+enum { Ident_1, Ident_2, Ident_3, Ident_4, Ident_5 }
+alias int Enumeration;
+
+/* for boolean and enumeration types in Ada, Pascal */
+
+/* General definitions: */
+
+const int StrLen = 30;
+
+alias int One_Thirty;
+alias int One_Fifty;
+alias char Capital_Letter;
+alias bool Boolean;
+alias char Str_30 [StrLen];
+alias int Arr_1_Dim [50];
+alias int Arr_2_Dim [50] [50];
+
+struct record
+{
+ record *Ptr_Comp;
+ Enumeration Discr;
+ union V
+ {
+ struct V1
+ {
+ Enumeration Enum_Comp;
+ int Int_Comp;
+ char Str_Comp [StrLen];
+ }
+ V1 var_1;
+ struct V2
+ {
+ Enumeration E_Comp_2;
+ char Str_2_Comp [StrLen];
+ }
+ V2 var_2;
+ struct V3
+ {
+ char Ch_1_Comp;
+ char Ch_2_Comp;
+ }
+ V3 var_3;
+ }
+ V variant;
+}
+
+alias record Rec_Type;
+alias record *Rec_Pointer;
+
+/* Global Variables: */
+
+Rec_Pointer Ptr_Glob,
+ Next_Ptr_Glob;
+int Int_Glob;
+Boolean Bool_Glob;
+char Ch_1_Glob,
+ Ch_2_Glob;
+int Arr_1_Glob [50];
+int Arr_2_Glob [50] [50];
+
+char[StrLen] Reg_Define = "Register option selected.";
+
+/* variables for time measurement: */
+
+const int Too_Small_Time = 2;
+
+/* Measurements should last at least 2 seconds */
+
+double Begin_Time,
+ End_Time,
+ User_Time;
+
+double Microseconds,
+ Dhrystones_Per_Second,
+ Vax_Mips;
+
+/* end of variables for time measurement */
+void main()
+
+/*****/
+
+/* main program, corresponds to procedures */
+/* Main and Proc_0 in the Ada version */
+{
+ One_Fifty Int_1_Loc;
+ One_Fifty Int_2_Loc;
+ One_Fifty Int_3_Loc;
+ char Ch_Index;
+ Enumeration Enum_Loc;
+ Str_30 Str_1_Loc;
+ Str_30 Str_2_Loc;
+ int Run_Index;
+ int Number_Of_Runs;
+
+ FILE *Ap;
+
+ /* Initializations */
+
+ if ((Ap = fopen("dhry.res", "a+")) == null)
+ {
+ printf("Can not open dhry.res\n\n");
+ exit(1);
+ }
+
+ Next_Ptr_Glob = cast(Rec_Pointer) malloc (Rec_Type.sizeof);
+ Ptr_Glob = cast(Rec_Pointer) malloc (Rec_Type.sizeof);
+
+ Ptr_Glob.Ptr_Comp = Next_Ptr_Glob;
+ Ptr_Glob.Discr = Ident_1;
+ Ptr_Glob.variant.var_1.Enum_Comp = Ident_3;
+ Ptr_Glob.variant.var_1.Int_Comp = 40;
+
+ // strcpy (Ptr_Glob.variant.var_1.Str_Comp,
+ // "DHRYSTONE PROGRAM, SOME STRING");
+ // strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
+ Ptr_Glob.variant.var_1.Str_Comp[] = "DHRYSTONE PROGRAM, SOME STRING";
+ Str_1_Loc[] = "DHRYSTONE PROGRAM, 1'ST STRING";
+
+ Arr_2_Glob [8][7] = 10;
+
+ /* Was missing in published program. Without this statement, */
+ /* Arr_2_Glob [8][7] would have an undefined value. */
+ /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
+ /* overflow may occur for this array element. */
+
+ printf ("\n");
+ printf ("Dhrystone Benchmark, Version 2.1 (Language: D)\n");
+ printf ("\n");
+ printf ("Please give the number of runs through the benchmark: ");
+ {
+ int n;
+
+ // scanf ("%d", &n);
+ n = 10000000;
+ Number_Of_Runs = n;
+ }
+ printf ("\n");
+
+ printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs);
+
+ /***************/
+ /* Start timer */
+ /***************/
+
+ Begin_Time = dtime();
+
+ for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
+ {
+ Proc_5();
+ Proc_4();
+
+ /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
+ Int_1_Loc = 2;
+ Int_2_Loc = 3;
+
+ // strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
+ Str_2_Loc[] = "DHRYSTONE PROGRAM, 2'ND STRING";
+ Enum_Loc = Ident_2;
+ Bool_Glob = !Func_2 (Str_1_Loc, Str_2_Loc);
+
+ /* Bool_Glob == 1 */
+ while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
+ {
+ Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
+
+ /* Int_3_Loc == 7 */
+ Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
+
+ /* Int_3_Loc == 7 */
+ Int_1_Loc += 1;
+ } /* while */
+
+ /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+ Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
+
+ /* Int_Glob == 5 */
+ Proc_1 (Ptr_Glob);
+
+ for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
+ {
+ /* loop body executed twice */
+ if (Enum_Loc == Func_1 (Ch_Index, 'C'))
+ {
+ /* then, not executed */
+ Proc_6 (Ident_1, &Enum_Loc);
+
+ // strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
+ Str_2_Loc[] = "DHRYSTONE PROGRAM, 3'RD STRING";
+ Int_2_Loc = Run_Index;
+ Int_Glob = Run_Index;
+ }
+ }
+
+ /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
+ Int_2_Loc = Int_2_Loc * Int_1_Loc;
+ Int_1_Loc = Int_2_Loc / Int_3_Loc;
+ Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
+
+ /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
+ Proc_2 (&Int_1_Loc);
+
+ /* Int_1_Loc == 5 */
+ } /* loop "for Run_Index" */
+
+ /**************/
+ /* Stop timer */
+ /**************/
+
+ End_Time = dtime();
+
+ printf ("Execution ends\n");
+ printf ("\n");
+ printf ("Final values of the variables used in the benchmark:\n");
+ printf ("\n");
+ printf ("Int_Glob: %d\n", Int_Glob);
+ printf (" should be: %d\n", 5);
+ printf ("Bool_Glob: %d\n", Bool_Glob);
+ printf (" should be: %d\n", 1);
+ printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
+ printf (" should be: %c\n", cast(int) 'A');
+ printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
+ printf (" should be: %c\n", cast(int) 'B');
+ printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
+ printf (" should be: %d\n", 7);
+ printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
+ printf (" should be: Number_Of_Runs + 10\n");
+ printf ("Ptr_Glob.\n");
+ printf (" Ptr_Comp: %d\n", cast(int) Ptr_Glob.Ptr_Comp);
+ printf (" should be: (implementation-dependent)\n");
+ printf (" Discr: %d\n", Ptr_Glob.Discr);
+ printf (" should be: %d\n", 0);
+ printf (" Enum_Comp: %d\n", Ptr_Glob.variant.var_1.Enum_Comp);
+ printf (" should be: %d\n", 2);
+ printf (" Int_Comp: %d\n", Ptr_Glob.variant.var_1.Int_Comp);
+ printf (" should be: %d\n", 17);
+ printf (" Str_Comp: %.*s\n", Ptr_Glob.variant.var_1.Str_Comp);
+ printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
+ printf ("Next_Ptr_Glob.\n");
+ printf (" Ptr_Comp: %d\n", cast(int) Next_Ptr_Glob.Ptr_Comp);
+ printf (" should be: (implementation-dependent), same as above\n");
+ printf (" Discr: %d\n", Next_Ptr_Glob.Discr);
+ printf (" should be: %d\n", 0);
+ printf (" Enum_Comp: %d\n", Next_Ptr_Glob.variant.var_1.Enum_Comp);
+ printf (" should be: %d\n", 1);
+ printf (" Int_Comp: %d\n", Next_Ptr_Glob.variant.var_1.Int_Comp);
+ printf (" should be: %d\n", 18);
+ printf (" Str_Comp: %.*s\n", Next_Ptr_Glob.variant.var_1.Str_Comp);
+ printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
+ printf ("Int_1_Loc: %d\n", Int_1_Loc);
+ printf (" should be: %d\n", 5);
+ printf ("Int_2_Loc: %d\n", Int_2_Loc);
+ printf (" should be: %d\n", 13);
+ printf ("Int_3_Loc: %d\n", Int_3_Loc);
+ printf (" should be: %d\n", 7);
+ printf ("Enum_Loc: %d\n", Enum_Loc);
+ printf (" should be: %d\n", 1);
+ printf ("Str_1_Loc: %.*s\n", Str_1_Loc);
+ printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
+ printf ("Str_2_Loc: %.*s\n", Str_2_Loc);
+ printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
+ printf ("\n");
+
+ User_Time = End_Time - Begin_Time;
+
+ if (User_Time < Too_Small_Time)
+ {
+ printf ("Measured time too small to obtain meaningful results\n");
+ printf ("Please increase number of runs\n");
+ printf ("\n");
+ }
+ else
+ {
+ Microseconds = User_Time * Mic_secs_Per_Second
+ / cast(double) Number_Of_Runs;
+ Dhrystones_Per_Second = cast(double) Number_Of_Runs / User_Time;
+ Vax_Mips = Dhrystones_Per_Second / 1757.0;
+
+ printf ("Register option selected? NO\n");
+ strcpy(Reg_Define.ptr, "Register option not selected.");
+ printf ("Microseconds for one run through Dhrystone: ");
+ printf ("%7.1lf \n", Microseconds);
+ printf ("Dhrystones per Second: ");
+ printf ("%10.1lf \n", Dhrystones_Per_Second);
+ printf ("VAX MIPS rating = %10.3lf \n", Vax_Mips);
+ printf ("\n");
+
+ fprintf(Ap, "\n");
+ fprintf(Ap, "Dhrystone Benchmark, Version 2.1 (Language: D)\n");
+ fprintf(Ap, "%.*s\n", Reg_Define);
+ fprintf(Ap, "Microseconds for one loop: %7.1lf\n", Microseconds);
+ fprintf(Ap, "Dhrystones per second: %10.1lf\n", Dhrystones_Per_Second);
+ fprintf(Ap, "VAX MIPS rating: %10.3lf\n", Vax_Mips);
+ fclose(Ap);
+ }
+}
+
+void Proc_1(Rec_Pointer Ptr_Val_Par)
+
+/******************/
+
+/* executed once */
+{
+ Rec_Pointer Next_Record = Ptr_Val_Par.Ptr_Comp;
+
+ /* == Ptr_Glob_Next */
+ /* Local variable, initialized with Ptr_Val_Par.Ptr_Comp, */
+ /* corresponds to "rename" in Ada, "with" in Pascal */
+
+ *Ptr_Val_Par.Ptr_Comp = *Ptr_Glob;
+ Ptr_Val_Par.variant.var_1.Int_Comp = 5;
+ Next_Record.variant.var_1.Int_Comp
+ = Ptr_Val_Par.variant.var_1.Int_Comp;
+ Next_Record.Ptr_Comp = Ptr_Val_Par.Ptr_Comp;
+ Proc_3 (&Next_Record.Ptr_Comp);
+
+ /* Ptr_Val_Par.Ptr_Comp.Ptr_Comp
+ == Ptr_Glob.Ptr_Comp */
+ if (Next_Record.Discr == Ident_1)
+ {
+ /* then, executed */
+ Next_Record.variant.var_1.Int_Comp = 6;
+ Proc_6 (Ptr_Val_Par.variant.var_1.Enum_Comp,
+ &Next_Record.variant.var_1.Enum_Comp);
+ Next_Record.Ptr_Comp = Ptr_Glob.Ptr_Comp;
+ Proc_7 (Next_Record.variant.var_1.Int_Comp, 10,
+ &Next_Record.variant.var_1.Int_Comp);
+ }
+ else /* not executed */
+ *Ptr_Val_Par = *Ptr_Val_Par.Ptr_Comp;
+} /* Proc_1 */
+void Proc_2(One_Fifty *Int_Par_Ref)
+
+/******************/
+/* executed once */
+/* *Int_Par_Ref == 1, becomes 4 */
+{
+ One_Fifty Int_Loc;
+ Enumeration Enum_Loc;
+
+ Int_Loc = *Int_Par_Ref + 10;
+
+ do /* executed once */
+ if (Ch_1_Glob == 'A')
+ {
+ /* then, executed */
+ Int_Loc -= 1;
+ *Int_Par_Ref = Int_Loc - Int_Glob;
+ Enum_Loc = Ident_1;
+ }
+
+ /* if */
+ while (Enum_Loc != Ident_1); /* true */
+} /* Proc_2 */
+void Proc_3(Rec_Pointer *Ptr_Ref_Par)
+
+/******************/
+/* executed once */
+/* Ptr_Ref_Par becomes Ptr_Glob */
+{
+ if (Ptr_Glob != null)
+ /* then, executed */
+ *Ptr_Ref_Par = Ptr_Glob.Ptr_Comp;
+
+ Proc_7 (10, Int_Glob, &Ptr_Glob.variant.var_1.Int_Comp);
+} /* Proc_3 */
+void Proc_4() /* without parameters */
+/*******/
+/* executed once */
+{
+ Boolean Bool_Loc;
+
+ Bool_Loc = Ch_1_Glob == 'A';
+ Bool_Glob = Bool_Loc | Bool_Glob;
+ Ch_2_Glob = 'B';
+} /* Proc_4 */
+void Proc_5() /* without parameters */
+/*******/
+/* executed once */
+{
+ Ch_1_Glob = 'A';
+ Bool_Glob = false;
+} /* Proc_5 */
+void Proc_6(Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par)
+
+/*********************************/
+/* executed once */
+/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
+{
+ *Enum_Ref_Par = Enum_Val_Par;
+
+ if (!Func_3 (Enum_Val_Par))
+ /* then, not executed */
+ *Enum_Ref_Par = Ident_4;
+
+ final switch (Enum_Val_Par)
+ {
+ case Ident_1:
+ *Enum_Ref_Par = Ident_1;
+ break;
+
+ case Ident_2:
+
+ if (Int_Glob > 100)
+ /* then */
+ *Enum_Ref_Par = Ident_1;
+ else *Enum_Ref_Par = Ident_4;
+
+ break;
+
+ case Ident_3: /* executed */
+ *Enum_Ref_Par = Ident_2;
+ break;
+
+ case Ident_4:
+ break;
+
+ case Ident_5:
+ *Enum_Ref_Par = Ident_3;
+ break;
+ } /* switch */
+
+} /* Proc_6 */
+void Proc_7(One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref)
+
+/**********************************************/
+/* executed three times */
+/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
+/* Int_Par_Ref becomes 7 */
+/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
+/* Int_Par_Ref becomes 17 */
+/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
+/* Int_Par_Ref becomes 18 */
+{
+ One_Fifty Int_Loc;
+
+ Int_Loc = Int_1_Par_Val + 2;
+ *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
+} /* Proc_7 */
+void Proc_8(ref Arr_1_Dim Arr_1_Par_Ref, ref Arr_2_Dim Arr_2_Par_Ref, int Int_1_Par_Val, int Int_2_Par_Val)
+
+/*********************************************************************/
+/* executed once */
+/* Int_Par_Val_1 == 3 */
+/* Int_Par_Val_2 == 7 */
+{
+ One_Fifty Int_Index;
+ One_Fifty Int_Loc;
+
+ Int_Loc = Int_1_Par_Val + 5;
+ Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
+ Arr_1_Par_Ref [Int_Loc + 1] = Arr_1_Par_Ref [Int_Loc];
+ Arr_1_Par_Ref [Int_Loc + 30] = Int_Loc;
+
+ for (Int_Index = Int_Loc; Int_Index <= Int_Loc + 1; ++Int_Index)
+ Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
+
+ Arr_2_Par_Ref [Int_Loc] [Int_Loc - 1] += 1;
+ Arr_2_Par_Ref [Int_Loc + 20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
+ Int_Glob = 5;
+} /* Proc_8 */
+Enumeration Func_1(Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val)
+
+/*************************************************/
+/* executed three times */
+/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
+/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
+/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
+{
+ Capital_Letter Ch_1_Loc;
+ Capital_Letter Ch_2_Loc;
+
+ Ch_1_Loc = Ch_1_Par_Val;
+ Ch_2_Loc = Ch_1_Loc;
+
+ if (Ch_2_Loc != Ch_2_Par_Val)
+ /* then, executed */
+ return (Ident_1);
+ else /* not executed */
+ {
+ Ch_1_Glob = Ch_1_Loc;
+ return (Ident_2);
+ }
+} /* Func_1 */
+Boolean Func_2(Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref)
+
+/*************************************************/
+/* executed once */
+/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
+/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
+{
+ One_Thirty Int_Loc;
+ Capital_Letter Ch_Loc;
+
+ Int_Loc = 2;
+
+ while (Int_Loc <= 2) /* loop body executed once */
+ if (Func_1 (Str_1_Par_Ref[Int_Loc],
+ Str_2_Par_Ref[Int_Loc + 1]) == Ident_1)
+ {
+ /* then, executed */
+ Ch_Loc = 'A';
+ Int_Loc += 1;
+ }
+
+ /* if, while */
+
+ if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
+ /* then, not executed */
+ Int_Loc = 7;
+
+ if (Ch_Loc == 'R')
+ /* then, not executed */
+ return (true);
+ else /* executed */
+ {
+ // if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
+ // if (memcmp (Str_1_Par_Ref, Str_2_Par_Ref, 30) > 0)
+ if (Str_1_Par_Ref > Str_2_Par_Ref)
+ {
+ /* then, not executed */
+ Int_Loc += 7;
+ Int_Glob = Int_Loc;
+ return (true);
+ }
+ else /* executed */
+ return (false);
+ } /* if Ch_Loc */
+
+} /* Func_2 */
+Boolean Func_3(Enumeration Enum_Par_Val)
+
+/***************************/
+/* executed once */
+/* Enum_Par_Val == Ident_3 */
+{
+ Enumeration Enum_Loc;
+
+ Enum_Loc = Enum_Par_Val;
+
+ if (Enum_Loc == Ident_3)
+ /* then, executed */
+ return (true);
+ else /* not executed */
+ return (false);
+} /* Func_3 */
+
+version (Win32)
+{
+ import std.c.windows.windows;
+
+ double dtime()
+ {
+ double q;
+
+ q = cast(double) GetTickCount() * 1.0e-03;
+
+ return q;
+ }
+}
+
+version (linux)
+{
+ import std.c.linux.linux;
+
+ double dtime()
+ {
+ double q;
+
+ q = cast(double) time(null);
+
+ return q;
+ }
+}
+
+version (OSX) // supplied by Anders F Bjorklund
+{
+ import std.c.linux.linux;
+
+ double dtime()
+ {
+ double q;
+ timeval tv;
+
+ gettimeofday(&tv, null);
+ q = cast(double) tv.tv_sec + cast(double) tv.tv_usec * 1.0e-6;
+
+ return q;
+ }
+}
View
412 samples/dserver.d
@@ -0,0 +1,412 @@
+
+/*
+ * Hello Object DLL Self-Registering Server
+ * Heavily modified from:
+ */
+/*
+ * SELFREG.CPP
+ * Server Self-Registrtation Utility, Chapter 5
+ *
+ * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
+ *
+ * Kraig Brockschmidt, Microsoft
+ * Internet : kraigb@microsoft.com
+ * Compuserve: >INTERNET:kraigb@microsoft.com
+ */
+
+import std.c.stdio;
+import std.c.stdlib;
+import std.c.string;
+import std.string;
+import std.c.windows.windows;
+import std.c.windows.com;
+
+import chello;
+
+// This class factory object creates Hello objects.
+
+class CHelloClassFactory : ComObject, IClassFactory
+{
+public:
+ this()
+ {
+ MessageBoxA(null, "CHelloClassFactory()", null, MB_OK);
+ }
+
+ ~this()
+ {
+ MessageBoxA(null, "~CHelloClassFactory()", null, MB_OK);
+ }
+
+ extern (Windows) :
+
+ // IUnknown members
+ HRESULT QueryInterface(const (IID)*riid, LPVOID *ppv)
+ {
+ MessageBoxA(null, "CHelloClassFactory.QueryInterface()", null, MB_OK);
+
+ if (IID_IUnknown == *riid)
+ {
+ MessageBoxA(null, "IUnknown", null, MB_OK);
+ *ppv = cast(void*) cast(IUnknown) this;
+ }
+ else if (IID_IClassFactory == *riid)
+ {
+ MessageBoxA(null, "IClassFactory", null, MB_OK);
+ *ppv = cast(void*) cast(IClassFactory) this;
+ }
+ else
+ {
+ *ppv = null;
+ return E_NOINTERFACE;
+ }
+
+ AddRef();
+ return NOERROR;
+ }
+
+ // IClassFactory members
+ HRESULT CreateInstance(IUnknown pUnkOuter, IID*riid, LPVOID *ppvObj)
+ {
+ CHello pObj;
+ HRESULT hr;
+
+ MessageBoxA(null, "CHelloClassFactory.CreateInstance()", null, MB_OK);
+ *ppvObj = null;
+ hr = E_OUTOFMEMORY;
+
+ // Verify that a controlling unknown asks for IUnknown
+ if (null !is pUnkOuter && memcmp(&IID_IUnknown, riid, IID.sizeof))
+ return CLASS_E_NOAGGREGATION;
+
+ // Create the object passing function to notify on destruction.
+ pObj = new CHello(pUnkOuter, &ObjectDestroyed);
+
+ if (!pObj)
+ return hr;
+
+ if (pObj.Init())
+ {
+ hr = pObj.QueryInterface(riid, ppvObj);
+ }
+
+ // Kill the object if initial creation or Init failed.
+ if (FAILED(hr))
+ delete pObj;
+ else
+ g_cObj++;
+
+ return hr;
+ }
+
+ HRESULT LockServer(BOOL fLock)
+ {
+ MessageBoxA(null, "CHelloClassFactory.LockServer()", null, MB_OK);
+
+ if (fLock)
+ g_cLock++;
+ else
+ g_cLock--;
+