Mercurial > projects > dil

comparison trunk/src/TypeRules.d @ 802:f51305056196

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added modules related to type rules.
author Aziz K?ksal <aziz.koeksal@gmail.com>
date Wed, 05 Mar 2008 15:45:54 +0100
parents dcd30b0ba711
children
comparison
equal deleted inserted replaced
801:c39667f1e814 802:f51305056196
2 Author: Aziz Köksal 2 Author: Aziz Köksal
3 License: GPL3 3 License: GPL3
4 +/ 4 +/
5 module TypeRules; 5 module TypeRules;
6 6
7 import cmd.Generate : xml_escape;
8
9 import TypeRulesData;
7 import common; 10 import common;
8
9 template ExpressionType(char[] T1, char[] T2, char[] expression)
10 {
11 mixin("alias "~T1~" X;");
12 mixin("alias "~T2~" Y;");
13 X x;
14 Y y;
15 static if(is(typeof(mixin(expression)) ResultType))
16 const char[] result = ResultType.stringof;
17 else
18 const char[] result = "Error";
19 }
20 alias ExpressionType EType;
21
22 // pragma(msg, EType!("char", "int", "&x").result);
23 11
24 static const string[] basicTypes = [ 12 static const string[] basicTypes = [
25 "char"[], "wchar", "dchar", "bool", 13 "char"[], "wchar", "dchar", "bool",
26 "byte", "ubyte", "short", "ushort", 14 "byte", "ubyte", "short", "ushort",
27 "int", "uint", "long", "ulong", 15 "int", "uint", "long", "ulong",
70 "x~=y", 58 "x~=y",
71 "x~y", 59 "x~y",
72 "x,y" 60 "x,y"
73 ]; 61 ];
74 62
75 char[] genBinaryExpArray(char[] expression)
76 {
77 char[] result = "[\n";
78 foreach (t1; basicTypes)
79 {
80 result ~= "[\n";
81 foreach (t2; basicTypes)
82 result ~= `EType!("`~t1~`", "`~t2~`", "`~expression~`").result,`\n;
83 result[result.length-2] = ']'; // Overwrite last comma.
84 result[result.length-1] = ','; // Overwrite last \n.
85 }
86 result[result.length-1] = ']'; // Overwrite last comma.
87 return result;
88 }
89 // pragma(msg, mixin(genBinaryExpArray("x%y")).stringof);
90
91 char[] genBinaryExpsArray()
92 {
93 char[] result = "[\n";
94 foreach (expression; binaryExpressions[0..42])
95 {
96 // pragma(msg, "asd");
97 result ~= genBinaryExpArray(expression)/+ ~ ",\n"+/;
98 result ~= ",\n";
99 }
100 result[result.length-2] = ']';
101 return result;
102 }
103
104 // pragma(msg, mixin(genBinaryExpsArray()).stringof);
105
106 char[] genUnaryExpArray(char[] expression)
107 {
108 char[] result = "[\n";
109 foreach (t1; basicTypes)
110 result ~= `EType!("`~t1~`", "int", "`~expression~`").result,`\n;
111 result[result.length-2] = ']'; // Overwrite last comma.
112 return result;
113 }
114
115 char[] genUnaryExpsArray()
116 {
117 char[] result = "[\n";
118 foreach (expression; unaryExpressions)
119 result ~= genUnaryExpArray(expression) ~ ",\n";
120 result[result.length-2] = ']';
121 return result;
122 }
123
124 // pragma(msg, mixin(genUnaryExpsArray()).stringof);
125
126 void genHTMLTypeRulesTables() 63 void genHTMLTypeRulesTables()
127 { 64 {
128 auto unaryExpsResults = mixin(genUnaryExpsArray());
129 // auto binaryExpsResults = mixin(genBinaryExpsArray());
130
131 Stdout( 65 Stdout(
132 `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">`\n 66 `<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">`\n
133 `<html>`\n 67 `<html>`\n
134 `<head>`\n 68 `<head>`\n
135 ` <meta http-equiv="Content-Type" content="text/html; charset=utf-8">`\n 69 ` <meta http-equiv="Content-Type" content="text/html; charset=utf-8">`\n
136 ` <link href="" rel="stylesheet" type="text/css">`\n 70 ` <link href="" rel="stylesheet" type="text/css">`\n
71 ` <style type="text/css">`\n
72 ` .E { color: darkred; } /* Error */`\n
73 ` .R { font-size: 0.8em; } /* Result */`\n
74 ` .X { color: darkorange; }`\n
75 ` .Y { color: darkblue; }`\n
76 ` </style>`\n
137 `</head>`\n 77 `</head>`\n
138 `<body>`\n 78 `<body>`\n
79 `<p>These tables show what the type results of certain expressions are.</p>`\n
139 ); 80 );
140 81
141 Stdout.format("<table>\n<tr><th colspan=\"{}\">Unary Expressions</th></tr>", unaryExpressions.length); 82 Stdout.format("<table>\n<tr><th colspan=\"{}\">Unary Expressions</th></tr>\n", unaryExpressions.length);
142 Stdout("<tr><td><!--typecol--></td>"); 83 Stdout("<tr><td><!--typecol--></td>");
143 foreach (unaryExpression; unaryExpressions) 84 foreach (unaryExpression; unaryExpressions)
144 Stdout.format("<td>{}</td>", unaryExpression); 85 Stdout.format("<td>{}</td>", {
86 if (unaryExpression[0] == 'x')
87 return `<span class="X">x</span>` ~ xml_escape(unaryExpression[1..$]);
88 else
89 return xml_escape(unaryExpression[0..$-1]) ~ `<span class="X">x</span>`;
90 }());
145 Stdout("</tr>\n"); 91 Stdout("</tr>\n");
146 foreach (i, basicType; basicTypes) 92 foreach (i, basicType; basicTypes)
147 { 93 {
148 Stdout.format("<tr>\n<td>{}</td>", basicType); 94 Stdout.format("<tr>\n"`<td class="X">{}</td>`, basicType);
149 foreach (unaryExpResults; unaryExpsResults) 95 foreach (expResults; unaryExpsResults)
150 { 96 {
151 assert(unaryExpResults.length == basicTypes.length); 97 auto result = expResults[i];
152 Stdout.format("<td>{}</td>", unaryExpResults[i]); 98 Stdout.format(`<td class="R">{}</td>`, result[0] == 'E' ? `<span class="E">Error</span>`[] : result);
153 } 99 }
154 Stdout("\n<tr>\n"); 100 Stdout("\n<tr>\n");
155 } 101 }
156 Stdout("</table>\n"); 102 Stdout("</table>\n");
157 103
158 foreach (binaryExpression; binaryExpressions) 104 foreach (i, expResults; binaryExpsResults)
159 { 105 {
160 Stdout.format("<table>\n<tr><th colspan=\"{}\">Binary Expression</th></tr>", basicTypes.length); 106 auto binaryExpression = binaryExpressions[i];
161 Stdout.format("<tr><td>{}</td>", binaryExpression); 107 binaryExpression = `<span class="X">x</span> ` ~
108 xml_escape(binaryExpression[1..$-1]) ~
109 ` <span class="Y">y</span>`;
110 Stdout.format("<table>\n<tr><th colspan=\"{}\">{}</th></tr>\n", basicTypes.length, binaryExpression);
111 Stdout.format("<tr><td><!--typecol--></td>");
112 foreach (basicType; basicTypes)
113 Stdout.format(`<td class="Y">{}</td>`, basicType);
162 Stdout("\n<tr>\n"); 114 Stdout("\n<tr>\n");
163 foreach (i, basicType; basicTypes) 115 foreach (j, results; expResults)
164 { 116 {
165 Stdout.format("<tr>\n<td>{}</td>", basicType); 117 Stdout.format("<tr>\n"`<td class="X">{}</td>`, basicTypes[j]);
166 // foreach (basicType; basicTypes) 118 foreach (result; results)
167 { 119 Stdout.format(`<td class="R">{}</td>`, result[0] == 'E' ? `<span class="E">Error</span>`[] : result);
168 }
169 Stdout("\n<tr>\n"); 120 Stdout("\n<tr>\n");
170 } 121 }
171 Stdout("</table>\n"); 122 Stdout("</table>\n");
172 } 123 }
173 124