mirrors/BitwiseCmd
1
0
Fork 0
mirror of https://github.com/BorysLevytskyi/BitwiseCmd.git synced 2025-12-10 06:52:05 +01:00
Code Issues Projects Releases Wiki Activity

Add support of binary numbers

Browse Source
This commit is contained in:
boryslevytskyi
2017-05-27 13:29:52 +03:00
parent fb4c5c9a06
commit edbd555f65
50 changed files with 259 additions and 2029 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src.old/css/styles.css
View File

@@ -1,103 +0,0 @@
body { font-family: Verdana; font-size: 0.8em; margin: 0; padding: 20px 100px 0 100px; }
code { font-size: 1.2em; font-weight: bold; }
.top-links { position: absolute; right: 10px; top: 10px; list-style-type: none; margin: 0 }
.top-links li { float: left; }
.top-links a { display: inline-block; padding: 10px 15px}
.top-links .icon { margin-right: 5px; }
.mono { font-family: monospace; font-size: 1.3em }
.expressionInput { width: 500px; padding: 3px; border: solid 1px lightgray; }
.result { margin: 10px 10px 30px; }
.result .input { margin-bottom: 10px; }
.result .content { padding-left: 10px}
.result .cur { margin-right: 5px; }
.hashLink { text-decoration: none; margin-left: 5px; visibility: hidden }
.hashLink:hover { text-decoration: underline; margin-left: 5px; }
.input:hover .hashLink { visibility: visible }
.expression .label { font-weight: bold; padding-right: 5px; text-align: right; }
.expression .bin { letter-spacing: 3px; }
.expression .flipable { cursor: pointer; opacity: 1 }
.expression .flipable:hover { opacity: 0.8 }
.expression .byte { margin: 0 3px; }
.expression .flipable { cursor: pointer; opacity: 1 }
.expression .flipable:hover { opacity: 0.8 }
.expression-result td { border-top: dotted 1px gray; }
.expression { font-size: 1.5em; font-family: monospace }
.expression .prefix { font-weight: normal; display: none; font-size: 0.9em }
.expression .other { font-size: 0.9em}
.expression .sign { text-align: right}
.hex .prefix { display: inline; }
.help { padding: 10px; }
.help ul { list-style-type: none; margin: 0; padding: 0; }
.help p { margin-top: 0 }
.indicator { padding: 2px 5px; font-family: monospace; font-size: 1.3em; background: transparent; border: none; cursor: pointer }
.error { color: maroon; }
#view { padding: 10px}
.cur { color: lightgray; }
.icon { width: 16px; height: 16px; display: inline-block; }
.light .twitter { background: url('../img/twitter-light.png') }
.dark .twitter { background: url('../img/twitter-dark.png') }
.light .feedback { background: url('../img/feedback-light.png') }
.dark .feedback { background: url('../img/feedback-dark.png') }
.dark .github { background: url('../img/github-dark.png') }
.light .github { background: url('../img/github-light.png') }
/* Light */
.light { background: #fafafa; }
.light a, .light a:visited { color: #222; }
.light .one { color: black; }
.light .zero { color: #888; }
.light .indicator { color: #ddd; }
.light .on { color: #121212; }
.light .prefix { color: #888}
.light .other { color: #bbb }
.light .hashLink, .light .hashLink:visited { color: #ddd }
.light .hashLink:hover { color: #888 }
.light ul.top-links li:hover { background: #ddd }
/* Dark */
.dark { background: #121212; color: white;}
.dark .expressionInput { background: #121212; color: white; }
.dark a, .dark a:visited { color: white; }
.dark .indicator { color: #555; }
.dark .on { color: white; }
.dark .zero { color: #999;}
.dark .prefix { color: #999}
.dark .other { color: #444;}
.dark .hashLink, .dark .hashLink:visited { color: #333 }
.dark .hashLink:hover { color: #999 }
.dark ul.top-links li:hover { background: #333 }
/* Top Links Shrink */
@media (max-width: 800px) {
.top-links .link-text { display: none }
}
/* Remove margin space on body. Inline top links with header */
@media (max-width: 700px) {
body { padding: 10px; }
.expressionInput { width: 500px; }
}
/* Further shrink */
@media (max-width: 500px) {
.expressionInput { width: 350px; }
.top-links a { display: inline-block; padding: 5px 10px}
}
@media (max-width: 350px) {
.expressionInput { width: 200px; }
}

BIN
src.old/favicon.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

BIN
src.old/img/feedback-dark.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

BIN
src.old/img/feedback-light.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

BIN
src.old/img/github-dark.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 470 B

BIN
src.old/img/github-light.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 605 B

BIN
src.old/img/twitter-dark.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

BIN
src.old/img/twitter-light.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

182
src.old/index.html
View File

@@ -1,182 +0,0 @@
<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<meta name="description" content="Bitwise Calculator. Visualised Bitwise Operations.">
<title>BitwiseCmd</title>
<link rel="shortcut icon" href="http://bitwisecmd.com/favicon.ico">
<!-- build:js js/bitwisecmd.js -->
<script type="text/javascript" src="js/core/core.js"></script>
<script type="text/javascript" src="js/core/is.js"></script>
<script type="text/javascript" src="js/core/should.js"></script>
<script type="text/javascript" src="js/core/di.js"></script>
<script type="text/javascript" src="js/core/appShell.js"></script>
<script type="text/javascript" src="js/core/htmlBuilder.js"></script>
<script type="text/javascript" src="js/core/observable.js"></script>
<script type="text/javascript" src="js/app.js"></script>
<script type="text/javascript" src="js/components/controllersFeature.js"></script>
<script type="text/javascript" src="js/components/viewsFeature.js"></script>
<script type="text/javascript" src="js/components/templatesFeature.js"></script>
<script type="text/javascript" src="js/app/bitwise/calc.js"></script>
<script type="text/javascript" src="js/app/bitwise/expression.js"></script>
<script type="text/javascript" src="js/app/bitwise/formatter.js"></script>
<script type="text/javascript" src="js/app/models.js"></script>
<script type="text/javascript" src="js/app/modelViews.js"></script>
<script type="text/javascript" src="js/app/cmd/cmd.js"></script>
<script type="text/javascript" src="js/app/services.js"></script>
<script type="text/javascript" src="js/app/controllers.js"></script>
<script type="text/javascript" src="js/app/cmd/commands.js"></script>
<script type="text/javascript" src="js/app/run.js"></script>
<!-- /build -->
<link rel="stylesheet" type="text/css" href="css/styles.css" />
</head>
<body id="rootView" class="dark">
<header>
<div class="header">
<h1>Bitwise<span style="color: #c5c5c5;">Cmd</span></h1>
<ul class="top-links">
<li>
<a href="https://github.com/BorisLevitskiy/BitwiseCmd"><i class="icon github">&nbsp;</i><span class="link-text">Project on GitHub</span></a>
</li>
<li>
<a href="https://twitter.com/BitwiseCmd"><i class="icon twitter">&nbsp;</i><span class="link-text">Twitter</span></a>
</li>
<li>
<a href="mailto:&#098;&#105;&#116;&#119;&#105;&#115;&#101;&#099;&#109;&#100;&#064;&#103;&#109;&#097;&#105;&#108;&#046;&#099;&#111;&#109;?subject=Feedback"><i class="icon feedback">&nbsp;</i><span class="link-text">Send Feedback</span></a>
</li>
</ul>
</div>
<div class="expressionInput-container">
<input id="in" type="text" class="expressionInput mono" data-controller="expressionInputCtrl" placeholder="type expression like '1>>2' or 'help' "/>
<span data-controller="configPanelCtrl" class="configPnl">
<span id="emphasizeBytes" data-cmd="em" class="indicator on" title="Emphasize Bytes">[em]</span>
</span>
</div>
</header>
<div id="output" data-controller="cmdController">
</div>
<script data-template="helpResultTpl" type="text/template">
<div class="help helpResultTpl">
<div style="overflow: hidden">
<div style="float: left; margin-right: 20px">
<p class="section">
<strong>Supported Commands</strong>
<ul>
<li><code>23 ^ 34</code> — type bitwise expression to see result in binary (only positive integers are supported now)</li>
<li><code>23 34</code> — type one or more numbers to see their binary representations</li>
<li><code>clear</code> — clear output pane</li>
<li><code>help</code> — display this help</li>
<li><code>em</code> — turn On/Off Emphasize Bytes</li>
<li><code>dark</code> — set Dark theme</li>
<li><code>light</code> — set Light theme</li>
<li><code>about</code> — about the app</li>
</ul>
</p>
</div>
<div class="float:left">
<p class="section">
<strong>Supported Bitwise Operations</strong><br/>
<small>
<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">
as implemented in JavaScript engine
</a>
</small>
<ul>
<li><code>&</code> — bitwise AND</li>
<li><code>|</code> — bitwise inclusive OR</li>
<li><code>^</code> — bitwise exclusive XOR</li>
<li><code>~</code> — bitwise NOT</li>
<li><code>&lt;<</code> — left shift</li>
<li><code>&gt;&gt;</code> — sign propagating right shift</li>
<li><code>&gt;&gt;&gt;</code> — zero-fill right shift</li>
</ul>
</p>
</div>
</div>
<p style="font-style: italic">
<strong>Tip:</strong> Use Up and Down keys to navigate trough executed commands.
</p>
</div>
</script>
<script data-template="aboutTpl" type="text/template">
<div class="aboutTpl">
<p> Created by <a href="http://boryslevytskyi.github.io/">Borys Levytskyi</a></p>
<p>If you have an idea, suggestion or you've spotted a bug here, please send it to <a href="mailto:&#098;&#105;&#116;&#119;&#105;&#115;&#101;&#099;&#109;&#100;&#064;&#103;&#109;&#097;&#105;&#108;&#046;&#099;&#111;&#109;?subject=Feedback">&#098;&#105;&#116;&#119;&#105;&#115;&#101;&#099;&#109;&#100;&#064;&#103;&#109;&#097;&#105;&#108;&#046;&#099;&#111;&#109;</a> or tweet on <a href="http://twitter.com/BitwiseCmd">@BitwiseCmd</a>. Your feedback is greatly appreciated.</p>
<p><a href="https://github.com/BorisLevitskiy/BitwiseCmd">Project on <strong>GitHub</strong></a></p>
</div>
</script>
<script data-template="resultView" data-compiled="" type="text/template">
<div class="result">
<div class="input mono"><span class="cur">&gt;</span>{m.input}<a class="hashLink" title="Link for this expression" href="{window.location.pathname}#{m.inputHash}">#</a></div>
<div class="content"></div>
</div>
</script>
<script data-template="bitwiseExpressionView" data-compiled="" type="text/template">
<table class="expression" cellspacing="0">
{each itm in m.items}
<tr class="{itm.css}">
<td class="sign">{itm.sign}</td>
<td class="label">{itm.label}</td>
<td class="bin">{itm.bin.padLeft(m.maxNumberOfBits, '0')}</td>
<td class="other">{itm.other}</td>
</tr>
{/}
</table>
</script>
<script data-template="numbersList" data-compiled="" type="text/template">
<table class="expression" cellspacing="0">
{each op in m.operands}
<tr data-kind="{op.kind}">
<td class="label">{op.input}</td>
<td class="bin">{op.bin.padLeft(m.bitsSize, '0')}</td>
<td class="other">{op.other}</td>
</tr>
{/}
</table>
</script>
<script type="text/javascript">
var app = window.app;
app.bootstrap(document.getElementById('rootView'));
var cmd = app.get('cmd');
var hashArgs = app.get('hashArgs');
if(hashArgs.commands.length > 0) {
hashArgs.commands.forEach(cmd.execute.bind(cmd));
}
else {
cmd.execute('help');
cmd.execute('1|2&6');
cmd.execute('1<<0x2a');
cmd.execute('2 4 8 16 32');
}
</script>
<!-- build:js js/analytics.js -->
<!-- /build -->
</body>
</html>

14
src.old/js/analytics.js
View File

@@ -1,14 +0,0 @@
(function() {
if(window.location.host != 'bitwisecmd.com' || window.location.hash.indexOf('-notrack') > -1) {
return;
}
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-61569164-1', 'auto');
ga('send', 'pageview');
})();

23
src.old/js/app.js
View File

@@ -1,23 +0,0 @@
(function (core) {
"use strict";
var di = new core.Container();
var app = new core.AppShell(di);
app.set('cmdConfig', core.ObservableObject.create({
emphasizeBytes: true,
theme: 'dark'
}));
app.debugMode = false;
app.bootstrap = function(rootViewElement) {
this.rootViewElement = rootViewElement;
this.set('rootView', rootViewElement)
this.initialize();
};
window.app = app;
})(window.core);

30
src.old/js/app/bitwise/calc.js
View File

@@ -1,30 +0,0 @@
app.set('calc', function() {
"use strict";
var should = app.get('should');
return {
numberOfBits: function (num) {
if(num < 0) {
return 32;
}
should.bePositiveInteger(num);
return Math.floor(Math.log(num) / Math.log(2)) + 1;
},
maxNumberOfBits: function (arr) {
var counts = [], num;
for (var i = 0; i < arr.length; i++) {
num = arr[i];
counts.push(this.numberOfBits(num));
}
return Math.max.apply(null, counts);
},
calcExpression: function (expr) {
return eval(expr.expressionString);
}
}
});

234
src.old/js/app/bitwise/expression.js
View File

@@ -1,234 +0,0 @@
app.set('expression', function() {
"use strict";
var expression = {
factories:[],
canParse: function(string) {
var trimmed = string.replace(/^\s+|\s+$/, '');
var i = this.factories.length-1;
for(;i>=0;i--) {
if(this.factories[i].canCreate(trimmed) === true){
return true;
}
}
return false;
},
parse: function(string) {
var trimmed = string.replace(/^\s+|\s+$/, '');
var i = 0, l = this.factories.length, factory;
for(;i<l;i++) {
factory = this.factories[i];
if(factory.canCreate(trimmed) == true){
return factory.create(trimmed);
}
}
return null;
},
parseOperand: function(input) {
return new Operand(input);
},
createOperand: function(number, kind) {
return Operand.create(number, kind);
},
addFactory: function(factory) {
this.factories.push(factory);
},
Operand:Operand,
TwoOperandExpression: TwoOperandExpression,
SingleOperandExpression: SingleOperandExpression,
ListOfNumbersExpression: ListOfNumbersExpression,
MultipleOperandsExpression: MultipleOperandsExpression
};
// List of numbers
expression.addFactory({
regex: /^(-?(?:\d+|0x[\d,a-f]+)\s?)+$/,
canCreate: function(string) {
return this.regex.test(string);
},
create: function (string) {
var matches = this.regex.exec(string),
numbers = [],
input = matches.input;
input.split(' ').forEach(function(n){
if(n.trim().length > 0) {
numbers.push(new Operand(n.trim()));
}
});
return new ListOfNumbersExpression(input, numbers);
}
});
// Not Expression
expression.addFactory({
regex: /^(~)(-?(?:\d+|0x[\d,a-f]+))$/,
canCreate: function(string) {
return this.regex.test(string);
},
create: function (string) {
var matches = this.regex.exec(string),
operand = new Operand(matches[2]);
return new SingleOperandExpression(matches.input, operand, matches[1]);
}
});
// Multiple operands expression
expression.addFactory({
fullRegex: /^((<<|>>|>>>|\||\&|\^)?(-?((?:\d+(?!x))|(?:0x[\d,a-f]+))))+$/,
regex: /(<<|>>|>>>|\||\&|\^)?(-?((?:\d+(?!x))|(?:0x[\d,a-f]+)))/g,
canCreate: function(string) {
this.fullRegex.lastIndex = 0;
return this.fullRegex.test(this.normalizeString(string));
},
create: function (string) {
var m, operands = [],
normalizedString = this.normalizeString(string);
while ((m = this.regex.exec(normalizedString)) != null) {
operands.push(this.parseMatch(m));
}
return new MultipleOperandsExpression(normalizedString, operands)
},
parseMatch: function (m) {
var input = m[0],
sign = m[1],
num = m[2];
if(sign == null) {
return new Operand(num);
} else {
return new SingleOperandExpression(input, new Operand(num), sign);
}
},
normalizeString: function (string) {
return string.replace(/\s+/g,'');
}
});
function Operand(input) {
this.input = input;
this.value = parseInt(input);
this.hex = Operand.toHexString(this.value.toString(16));
this.dec = this.value.toString(10);
// >>> 0 makes negative numbers like -1 to be displayed as '11111111111111111111111111111111' in binary instead of -1
this.bin = this.value < 0 ? (this.value >>> 0).toString(2) : this.value.toString(2);
this.kind = this.input.indexOf('0x') > -1 ? 'hex' : 'dec';
this.other = this.kind == 'dec' ? this.hex : this.dec;
}
Operand.toHexString = function (hex) {
return hex.indexOf('-') == 0 ? '-0x' + hex.substr(1) : '0x' + hex;
};
Operand.create = function(number, kind) {
var str = number.toString(Operand.getBase(kind));
if(kind == 'hex') {
str = Operand.toHexString(str);
}
return new Operand(str);
};
Operand.prototype.getLengthInBits = function() {
if(this.value < 0) {
return 32;
}
return Math.floor(Math.log(this.value) / Math.log(2)) + 1;
};
Operand.getBase = function(kind){
switch (kind){
case 'bin': return 2;
case 'hex': return 16;
case 'dec': return 10;
}
};
function SingleOperandExpression(expressionString, operand, sign) {
this.expressionString = expressionString;
this.operand1 = operand;
this.sign = sign;
}
SingleOperandExpression.prototype.apply = function (value) {
var str = '';
if(this.sign == '~'){
str = '~' + this.operand1.value;
} else {
str = value + this.sign + this.operand1.value
}
return Operand.create(eval(str), this.operand1.kind);
};
SingleOperandExpression.prototype.isShiftExpression = function () {
return this.sign.indexOf('<') >= 0 || this.sign.indexOf('>')>= 0;
};
function TwoOperandExpression(expressionString, operand1, operand2, sign) {
this.expressionString = expressionString;
this.operand1 = operand1;
this.operand2 = operand2;
this.sign = sign;
}
function MultipleOperandsExpression(expressionString, expressions) {
this.expressionString = expressionString;
this.expressions = expressions;
}
function ListOfNumbersExpression(expressionString, numbers) {
this.expressionString = expressionString;
this.numbers = numbers;
}
function Expression() {
}
Expression.prototype.toString = function() {
return this.expressionString ? "Expression: " + this.expressionString : this.toString();
};
//TwoOperandExpression.prototype = Expression.prototype;
//SingleOperandExpression.prototype = Expression.prototype;
//ListOfNumbersExpression.prototype = Expression.prototype;
Operand.prototype.toString = function () {
return this.input;
};
SingleOperandExpression.prototype.toString = function() {
return this.sign + this.operand1.toString();
};
Operand.toKindString = function(value, kind) {
switch(kind) {
case 'hex':
var hexVal = Math.abs(value).toString(16);
return value >= 0 ? '0x' + hexVal : '-0x' + hexVal;
case 'bin':
return (value>>>0).toString(2);
case 'dec':
return value.toString(10);
default:
throw new Error("Unexpected kind: " + kind)
}
};
Operand.getOtherKind = function(kind) {
switch(kind) {
case 'dec': return 'hex';
case 'hex': return 'dec';
default : throw new Error(kind + " kind doesn't have opposite kind")
}
};
return expression;
});

33
src.old/js/app/bitwise/formatter.js
View File

@@ -1,33 +0,0 @@
app.set("formatter", function() {
"use strict";
var should = app.get('should');
var is = app.get('is');
return {
formatString: function(num, kind) {
return num.toString(getBase(kind || "bin"));
},
padLeft: function (str, length, symbol) {
var sb = Array.prototype.slice.call(str), symbol = symbol || "0";
if(length == null) {
return str;
}
while(length > sb.length) {
sb.unshift(symbol);
}
return sb.join('');
}
};
function getBase(kind) {
switch (kind){
case 'bin': return 2;
case 'hex': return 16;
case 'dec': return 10;
}
}
});

92
src.old/js/app/cmd/cmd.js
View File

@@ -1,92 +0,0 @@
app.set('cmd', function() {
"use strict";
var handlers = [];
var is = app.get('is');
var cmdController = app.controller('cmdController');
return {
debugMode: true,
execute: function(rawInput) {
var input = rawInput.trim().toLowerCase();
var handler = findHandler(input);
if(handler != null) {
if(this.debugMode) {
invokeHandler(input, handler);
} else {
try {
invokeHandler(input, handler);
} catch (e) {
displayCommandError(input, "Error: " + e);
}
}
}
else {
displayCommandError(input, "Unsupported expression: " + input.trim());
}
},
commands: function(catalog) {
for(var key in catalog) {
if(catalog.hasOwnProperty(key)) {
this.command(key, catalog[key]);
}
}
},
command: function(cmd, handler) {
var h = createHandler(cmd, handler);
if(h == null){
console.warn('unexpected set of arguments: ', Array.prototype.splice.call(arguments));
return;
}
if(!is.aFunction(h.canHandle)) {
console.warn('handler is missing "canHandle" function. registration denied.');
return;
}
if(!is.aFunction(h.handle)) {
console.warn('handler is missing "handle" function. registration denied.');
return;
}
handlers.push(h);
},
clear: function() {
console.error('[displayCommandError] not implemented');
}
};
function displayCommandError(input, message) {
console.error('[displayCommandError] not implemented');
}
function invokeHandler (input, handler) {
var cmdResult = handler.handle(input);
if(cmdResult != null) {
var r = new app.models.DisplayResult(input, cmdResult);
cmdController.display(r);
}
}
function createHandler (cmd, handler) {
if(is.plainObject(cmd)) {
return cmd;
}
if(is.string(cmd)) {
return { canHandle: function (input) { return input === cmd; }, handle: handler };
}
return null;
}
function findHandler (input) {
var i= 0;
for(i;i<handlers.length; i++) {
if(handlers[i].canHandle(input)) {
return handlers[i];
}
}
}
});

44
src.old/js/app/cmd/commands.js
View File

@@ -1,44 +0,0 @@
app.run(function() {
"use strict";
var cmd = app.get('cmd');
var cmdConfig = app.get('cmdConfig');
var rootView = app.get('rootView');
var expression = app.get('expression');
// TODO: Make as function
cmd.command({
canHandle: function(input) { return app.get('expression').canParse(input); },
handle: function(input) {
var expr = expression.parse(input);
return this.locateModel(expr);
},
locateModel: function (expr) {
if(expr instanceof expression.ListOfNumbersExpression) {
return new app.models.BitwiseNumbersViewModel(expr);
}
if(expr instanceof expression.SingleOperandExpression ){
return new app.models.BitwiseExpressionViewModel.buildNot(expr);
}
if(expr instanceof expression.MultipleOperandsExpression) {
return new app.models.BitwiseExpressionViewModel.buildMultiple(expr);
}
return new app.models.ErrorResult('Cannot create model for expression: ' + expr.toString());
}
});
function moveResultUp(helpResult) {
var container = helpResult.parentNode.parentNode;
if(container.parentNode.firstChild != container) {
var out = container.parentNode;
out.removeChild(container);
out.insertBefore(container, out.firstChild);
}
}
});

95
src.old/js/app/controllers.js
View File

@@ -1,95 +0,0 @@
"use strict";
app.controller('expressionInputCtrl', function (){
var cmd = app.get('cmd');
return {
onViewAttached: function () {
var self = this;
self.history =[];
self.historyIndex = 0;
this.viewElement.focus();
this.viewElement.addEventListener('keyup', function (args) {
var inpt = args.target;
if (args.keyCode != 13 || inpt.value.trim().length == 0) {
return;
}
// Enter
cmd.execute(inpt.value);
self.history.unshift(inpt.value);
self.historyIndex = 0;
inpt.value = '';
});
this.viewElement.addEventListener('keydown', function(args){
if(args.keyCode == 38) {
if (self.history.length > self.historyIndex) { // up
args.target.value = self.history[self.historyIndex++];
}
args.preventDefault();
return;
}
if(args.keyCode == 40) {
if(self.historyIndex > 0) { // up
args.target.value = self.history[--self.historyIndex];
}
args.preventDefault();
}
})
}
}
});
app.controller('cmdController', function() {
var html = app.get('html');
var rootView = app.get('rootView');
return {
clear: function () {
this.viewElement.innerHTML = '';
},
display: function ( model) {
var view = app.buildViewFor(model);
var vw = this.viewElement;
if(vw.childNodes.length == 0) {
vw.appendChild(view);
}
else {
vw.insertBefore(view, vw.childNodes[0]);
}
}
};
});
app.controller('configPanelCtrl', {
onViewAttached: function (){
var self = this;
var cfg = app.get('cmdConfig');
self.update(cfg);
cfg.observe(function(){
self.update(cfg);
});
},
update: function (cfg) {
var emIndicator = this.viewElement.querySelector('#emphasizeBytes');
var reg = /\son/g;
if(cfg.emphasizeBytes) {
emIndicator.classList.add("on");
} else {
emIndicator.classList.remove("on");
}
}
});

119
src.old/js/app/modelViews.js
View File

@@ -1,119 +0,0 @@
// Expression View
app.compose(function () {
"use strict";
var formatter = app.get('formatter');
var calc = app.get('calc');
var html = app.get('html');
var cmdConfig = app.get('cmdConfig');
var expression = app.get('expression');
// TODO: move to protojs
String.prototype.padLeft = function(size, char) { return formatter.padLeft(this, size, char); }
app.modelView(app.models.BitwiseExpressionViewModel, {
renderView: function(model) {
var template = app.template('bitwiseExpressionView');
return colorizeBits(template.render(model));
}
});
app.modelView(app.models.BitwiseNumbersViewModel, {
renderView: function(model) {
model.bitsSize = getBinaryLength(model.numbers);
var templateElement = colorizeBits(app.template('numbersList').render(model));
var list = templateElement.querySelectorAll('.bit');
Array.prototype.forEach.call(list, function(el) {
el.classList.add('flipable');
el.setAttribute('title', 'Click to flip this bit');
el.addEventListener('click', flipBits);
});
return templateElement;
}
});
app.modelView(app.models.ViewResult, {
renderView: function(model) {
var template = app.template(model.template);
return template.render();
}
});
app.modelView(app.models.ErrorResult, {
renderView: function(model) {
return html.element('<div class="error">{message}</div>', model);
}
});
app.modelView(app.models.DisplayResult, {
renderView: function(model) {
var resultView = app.template('resultView').render(model);
var contentView = app.buildViewFor(model.content);
resultView.querySelector('.content').appendChild(contentView);
return resultView;
}
});
function getBinaryLength(arr) {
var bits = calc.maxNumberOfBits(arr);
if(cmdConfig.emphasizeBytes && bits % 8 != 0) {
if(bits < 8) {
return 8;
}
var n = bits - (bits % 8);
return n + 8;
}
return bits;
}
function colorizeBits(container) {
var list = container.querySelectorAll('.bin');
Array.prototype.forEach.call(list, function(el){
var bin = el.textContent;
if(cmdConfig.emphasizeBytes) {
bin = bin.replace(/(\d{8})/g, '<span class="byte">$1</span>');
}
el.innerHTML = bin
.replace(/0/g, '<span class="bit zero">0</span>')
.replace(/1/g, '<span class="bit one">1</span>');
});
return container;
}
function flipBits(evt) {
var el = evt.target;
var content = el.textContent;
if(content == '0') {
el.innerHTML = '1';
el.classList.remove('zero');
el.classList.add('one');
} else {
el.innerHTML = '0';
el.classList.add('zero');
el.classList.remove('one');
}
var row = findParent(el, 'TR');
var value = parseInt(row.cells[1].textContent, 2);
var kind = row.dataset.kind;
row.cells[0].innerHTML = expression.Operand.toKindString(value, kind);
row.cells[2].innerHTML = expression.Operand.toKindString(value, expression.Operand.getOtherKind(kind));
}
function findParent(el, tagName) {
var parent = el.parentNode;
while(parent.tagName != tagName) {
parent = parent.parentNode;
}
return parent;
}
});

117
src.old/js/app/models.js
View File

@@ -1,117 +0,0 @@
(function(app) {
"use strict";
function BitwiseOperation (expr) {
this.expression = expr;
this.operand1 = expr.operand1;
this.operand2 = expr.operand2;
this.sign = expr.sign;
this.string = expr.expressionString;
}
function BitwiseNumbersViewModel(expr) {
this.expression = expr;
this.operands = expr.numbers;
var numbers = this.numbers = [];
expr.numbers.forEach(function (o) {
numbers.push(o.value);
});
}
function BitwiseExpressionViewModel() {
this.items = [];
this.maxNumberOfBits = 0;
}
BitwiseExpressionViewModel.buildMultiple = function (expr) {
var op = expr.expressions[0],
i = 1, l = expr.expressions.length,
ex, m = new BitwiseExpressionViewModel();
m.addOperand(op);
for (;i<l;i++) {
ex = expr.expressions[i];
op = ex.apply(op.value);
if(ex.isShiftExpression()){
m.addShiftExpressionResult(ex, op);
} else {
m.addExpression(ex);
m.addExpressionResult(op);
}
}
m.maxNumberOfBits = m.emphasizeBytes(m.maxNumberOfBits);
return m;
};
BitwiseExpressionViewModel.buildNot = function (expression) {
var m = new BitwiseExpressionViewModel();
m.addExpression(expression);
m.addExpressionResult(expression.apply());
m.maxNumberOfBits = m.emphasizeBytes(m.maxNumberOfBits);
return m;
};
BitwiseExpressionViewModel.prototype.addOperand = function(operand) {
this.maxNumberOfBits = Math.max(operand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign:'', label: operand.toString(), bin: operand.bin, other: operand.other, css: ''});
};
BitwiseExpressionViewModel.prototype.addExpression = function(expression) {
this.maxNumberOfBits = Math.max(expression.operand1.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign: expression.sign, label: expression.operand1.input, bin: expression.operand1.bin, other: expression.operand1.other, css: ''});
};
BitwiseExpressionViewModel.prototype.addShiftExpressionResult = function(expression, resultOperand) {
this.maxNumberOfBits = Math.max(resultOperand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({
sign: expression.sign + expression.operand1.input,
label: resultOperand,
bin: resultOperand.bin,
other: resultOperand.other,
css: 'expression-result'});
};
BitwiseExpressionViewModel.prototype.addExpressionResult = function(operand) {
this.maxNumberOfBits = Math.max(operand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign:'=', label: operand.toString(), bin: operand.bin, other: operand.other, css: 'expression-result'});
};
BitwiseExpressionViewModel.prototype.emphasizeBytes = function (bits) {
var cmdConfig = app.get('cmdConfig');
if(cmdConfig.emphasizeBytes && bits % 8 != 0) {
if(bits < 8) {
return 8;
}
var n = bits - (bits % 8);
return n + 8;
}
return bits;
};
function ErrorResult(message) {
this.message = message;
}
function ViewResult (template) {
this.template = template;
}
function DisplayResult (input, content) {
this.input = input;
this.inputHash = app.get('hash').encodeHash(input);
this.content = content;
}
app.models.BitwiseExpressionViewModel = BitwiseExpressionViewModel;
app.models.BitwiseNumbersViewModel = BitwiseNumbersViewModel;
app.models.ErrorResult = ErrorResult;
app.models.ViewResult = ViewResult;
app.models.DisplayResult = DisplayResult;
})(window.app);

52
src.old/js/app/run.js
View File

@@ -1,52 +0,0 @@
// Theme change
app.run(function(){
var rootView = app.get('rootView');
var cmdConfig = app.get('cmdConfig');
cmdConfig.observe('theme', function (theme) {
var theOther = theme == 'dark' ? 'light' : 'dark';
if(rootView.classList.contains(theme)) {
return;
}
rootView.classList.remove(theOther);
rootView.classList.add(theme);
});
});
// Save config in local store
app.run(function() {
var cfg = app.get('cmdConfig');
var storeKey = 'cmdConfig';
load();
cfg.observe(function(property, value){
save();
});
function save() {
localStorage.setItem(storeKey, JSON.stringify(cfg.store()));
}
function load() {
var json = localStorage.getItem(storeKey), stored;
if(core.is.string(json)) {
stored = JSON.parse(json);
for(var key in stored) {
cfg[key] = stored[key];
}
}
}
});
// Cmd controls
app.run(function () {
var controls = app.get('rootView').querySelectorAll('[data-cmd]');
Array.prototype.forEach.call(controls, function(el) {
el.addEventListener('click', function(e) {
app.get('cmd').execute(e.target.getAttribute('data-cmd'));
});
});
});

60
src.old/js/app/services.js
View File

@@ -1,60 +0,0 @@
(function(app, core){
"use strict";
app.set('html', core.html);
app.set('is', core.is);
app.set('should', core.should);
app.set('bindr', core.bindr);
app.set('hash', function () {
return {
encodeHash: function(string) {
return encodeURI(string.trim().replace(/\s/g,','));
},
decodeHash: function(hashValue) {
return decodeURI(hashValue).replace(/^\#/, '').replace(/,/g,' ');
},
getArgs: function (hashValue) {
core.should.beString(hashValue, 'hashValue');
var decodedHash = this.decodeHash(hashValue),
args = {
commands: []
};
splitHashList(decodedHash).forEach(function(value) {
if(/^\-[a-zA-Z]+$/.test(value)) {
args[value.substr(1)] = true;
return;
}
args.commands.push(value);
});
return Object.freeze(args);
}
};
function splitHashList(str) {
var values = [];
if(str.indexOf('||')) {
str.split('||').forEach(function (v) {
if (v.length > 0) {
values.push(v);
}
});
} else {
values.push(str);
}
return values;
}
});
app.set('hashArgs', function() {
return app.get('hash').getArgs(window.location.hash);
})
})(window.app, window.core);

80
src.old/js/components/controllersFeature.js
View File

@@ -1,80 +0,0 @@
(function(app, core) {
"use strict";
var should = core.should;
app.controller = function(name, instOrFactory) {
should.beString(name, "name");
if(instOrFactory == null) {
return this.get(name);
}
var reg = new core.Container.Registration(instOrFactory);
reg.onFirstTimeResolve = function (inst) {
addControllerMixin(inst);
};
this.set(name, reg);
};
app.run(function(){
attachControllers(app.get('rootView'), app.di);
});
function addControllerMixin(ctrl) {
ctrl.attachView = function(viewElement) {
this.viewElement = viewElement;
if(typeof ctrl.onViewAttached == 'function') {
ctrl.onViewAttached(viewElement);
}
};
ctrl.detachView = function() {
this.viewElement = null;
if(typeof ctrl.onViewDetached == 'function') {
ctrl.onViewDetached(viewElement);
}
};
}
function attachControllers(rootViewElement) {
var elements = rootViewElement.querySelectorAll('[data-controller]'),
i = 0, l = elements.length,
ctrlName,
ctrl, element;
for(;i<l;i++){
element = elements[i];
ctrlName = element.getAttribute('data-controller');
ctrl = app.controller(ctrlName);
if(ctrl == null) {
console.warn(ctrlName + ' controller wasn\'t found');
continue;
}
ctrl.attachView(element);
// console.log(ctrlName + ' Controller: view attached');
if(typeof ctrl.detachView != "function") {
continue;
}
// TODO: get rid from closure
element.addEventListener('DOMNodeRemoved', function (evt) {
if(element === evt.target) {
ctrl.detachView();
}
// console.log(ctrlName + ' Controller: view detached');
});
}
}
})(window.app, window.core);

51
src.old/js/components/templatesFeature.js
View File

@@ -1,51 +0,0 @@
(function(app) {
"use strict";
function Template(html, isCompiled) {
this.html = html;
this.isCompiled = isCompiled === true;
}
Template.prototype.render = function (model) {
if(this.isCompiled) {
return app.get('html').element(this.process(model));
}
return app.get('html').element(this.html, model);
};
app.templates = [];
app.template = function (key) {
var tpl = this.templates[key];
if(tpl == null) {
throw new Error(key + ' template is not found');
}
return tpl;
};
app.run(function() {
readTemplates(app.get('rootView'));
});
function readTemplates(containerEl) {
var els = containerEl.querySelectorAll('[data-template]');
var store = app.templates;
Array.prototype.forEach.call(els, function (element) {
var key = element.getAttribute('data-template');
if (store[key] instanceof Template) {
console.warn(key + ' templates already registered');
return;
}
var template = new Template(element.innerHTML);
store[key] = template;
if (element.hasAttribute('data-compiled')) {
template.process = app.get('html').compileTemplate(template.html);
template.isCompiled = true;
}
});
}
})(window.app);

24
src.old/js/components/viewsFeature.js
View File

@@ -1,24 +0,0 @@
(function(app, is){
"use strict";
app.modelView = function (modelCtor, builder) {
var name = getKey(modelCtor);
app.di.register(name, builder);
};
app.buildViewFor = function(model) {
var key = getKey(model.constructor);
var builder = this.di.resolve(key);
return builder.renderView(model);
};
function getKey(modelCtor) {
return getFunctionName(modelCtor) + "ViewBuilder";
}
function getFunctionName(func) {
var str = func.toString();
return str.substr(8, str.indexOf('(') - 8).trim();
}
})(window.app, window.is);

37
src.old/js/core/appShell.js
View File

@@ -1,37 +0,0 @@
(function() {
"use strict";
function AppShell(diContainer) {
this.models = {};
this.di = diContainer;
this.runList = [];
this.compositionList = [];
}
AppShell.prototype.get = function(name) {
return this.di.resolve(name);
};
AppShell.prototype.set = function(name, def) {
this.di.register(name, def);
};
AppShell.prototype.run = function(func) {
this.runList.push(func);
};
AppShell.prototype.compose = function (func) {
this.compositionList.push(func);
};
AppShell.prototype.initialize = function () {
callInvocationList(this.compositionList);
callInvocationList(this.runList);
};
function callInvocationList(functions) {
functions.forEach(function(o){ o(); });
}
window.core.AppShell = AppShell;
})();

1
src.old/js/core/core.js
View File

@@ -1 +0,0 @@
window.core = {};

106
src.old/js/core/di.js
View File

@@ -1,106 +0,0 @@
(function(core){
"use strict";
var is = core.is;
function Container(store) {
this.store = store || {};
this.resolutionStack = [];
}
Container.prototype.register = function(name, def) {
var reg;
if(this.store[name] != null) {
console.warn("Previous registration for [%1] has been replaced", name);
}
if(def instanceof Registration) {
reg = def;
}
else {
reg = new Registration(def);
}
reg.name = name;
this.store[name] = reg;
// console.log('[' + name + '] component registered');
return reg;
};
Container.prototype.resolve = function(name) {
return resolveInternal.call(this, name);
};
function resolveInternal(name) {
if(contains(this.resolutionStack, name)) {
throw new Error("Failed to resolve dependency: " + name + ". Circular reference: " + this.resolutionStack.join(' < '));
}
this.resolutionStack.unshift(name);
// console.log('\tresolution path:' + this.resolutionStack.join(' < '));
var reg = this.store[name];
if(reg == null) {
throw new Error(name + ' component is not registered');
}
if(reg.resolved == null) {
reg.createInstance();
}
this.resolutionStack.shift();
// console.log('\tresolution path:' + this.resolutionStack.join(' < '));
return reg.resolved;
}
Container.prototype.clone = function () {
var newStore = {};
for(var key in this.store) {
newStore[key] = this.store[key];
}
return new Container(newStore);
};
function Registration(definition) {
this.def = definition;
this.resolved = null;
}
Registration.prototype.createInstance = function() {
var def = this.def;
if(typeof def == "function") {
this.resolved = def();
}
else {
// this.resolveProperties(inst);
this.resolved = def;
}
if(is.aFunction(this.onFirstTimeResolve)){
this.onFirstTimeResolve(this.resolved);
}
// console.log('resolved:', this.name);
};
Container.Registration = Registration;
function contains(arr, item) {
var i = arr.length;
while(i-- > 0) {
if(arr[i] === item) {
return true;
}
}
return false;
}
core.Container = Container;
})(window.core);

95
src.old/js/core/htmlBuilder.js
View File

@@ -1,95 +0,0 @@
(function(core){
"use strict";
var html = {};
var should = core.should;
html.element = function(template, model) {
var el = document.createElement('div');
el.innerHTML = html.template(template, model);
return el.children[0];
};
html.template = function(template, model) {
should.beString(template, "template");
var regex = /(?:{([^}]+)})/g, htmlText;
if(model == null){
htmlText = template;
} else {
htmlText = template.replace(regex, function(m, g1) {
return html.escapeHtml(model[g1]);
});
}
return htmlText;
};
html.compileTemplate = function (template) {
var regex = /(?:{([^}]+)})/g;
var sb = [];
sb.push('(function() {')
sb.push('return function (m) { ')
sb.push('\tvar html = [];')
var m, index = 0;
while ((m = regex.exec(template)) !== null) {
if(m.index > index) {
sb.push("\t\thtml.push('" + normalize(template.substr(index, m.index - index)) + "');");
}
sb.push(replaceToken(m[1]));
index = m.index + m[0].length;
}
if(index < template.length - 1) {
sb.push("\t\thtml.push('" + normalize(template.substr(index, template.length - index)) + "');");
}
sb.push("\treturn html.join('');");
sb.push('}');
sb.push('})()');
//console.log(eval(sb.join('\r\n')).toString());
return eval(sb.join('\r\n'));
};
function normalize(str) {
return str.replace(/(\r|\n)+/g, '').replace("'", "\\\'");
}
html.escapeHtml = function(obj) {
if(obj == null) {
return obj;
}
if(typeof obj != 'string') {
obj = obj.toString();
}
return obj
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;")
.replace(/'/g, "&#039;");
};
function replaceToken(token, indent) {
if(token.indexOf('each') == 0) {
var r = /([\w\.]+)\sin\s([\w\.]+)/g;
var m = r.exec(token);
var v = m[1];
var col = m[2];
return 'var '+ v + '_list = '+ col + '.slice(), ' + v + ';\r\nwhile(('+v+'='+v+'_list.splice(0,1)[0])!==undefined)\r\n{';
}
if(token == '/') {
return "}";
}
return '\t\thtml.push(' + token + ');'
}
core.html = html;
})(window.core);

37
src.old/js/core/is.js
View File

@@ -1,37 +0,0 @@
(function(){
"use strict";
window.core.is = {
plainObject: function(obj) {
return typeof obj == "object" && obj instanceof Object;
},
aFunction: function (obj) {
return typeof obj == "function";
},
string: function (obj) {
return typeof obj == "string";
},
regex: function (obj) {
return typeof obj == "object" && this.constructedFrom(RegExp);
},
constructedFrom: function (obj, ctor) {
return obj instanceof ctor;
},
htmlElement: function(obj) {
return obj instanceof HtmlElement;
},
array: function(obj) {
return obj instanceof Array;
},
number: function(num) {
return typeof num == "number" && !isNaN(num)
}
};
})();

80
src.old/js/core/observable.js
View File

@@ -1,80 +0,0 @@
(function(core){
"use strict";
var is = core.is;
function ObservableObject () {
this.$store = {};
this.$executionHandlers = [];
}
ObservableObject.create = function(definition){
var obj = new ObservableObject();
for(var property in definition){
if(!definition.hasOwnProperty(property)){
continue;
}
Object.defineProperty(obj, property, {
get:ObservableObject.createGetter(property),
set:ObservableObject.createSetter(property)
});
obj[property] = definition[property];
}
return Object.seal(obj);
};
ObservableObject.createGetter = function (propertyName, store){
return function(){
return this.$store[propertyName];
}
};
ObservableObject.createSetter = function(propertyName, store){
return function(value){
this.$store[propertyName] = value;
this.notifyPropertyChanged(propertyName, value);
}
};
ObservableObject.prototype.observe = function (property, handler){
var func;
if(is.aFunction(property)) {
func = property;
}
else if(is.string(property) && is.aFunction(handler)) {
func = function (p, v) {
if(p === property) {
handler(v)
}
}
}
else {
console.warn('Unsupported set of arguments: ', arguments);
return;
}
var handlers = this.$executionHandlers;
var index = handlers.push(func);
return function () { handlers.splice(1, index); }
};
ObservableObject.prototype.notifyPropertyChanged = function(propertyName, value){
this.$executionHandlers.forEach(function(h){
h(propertyName, value);
});
};
ObservableObject.prototype.store = function() {
return this.$store;
};
ObservableObject.prototype.keys = function() {
return Object.keys(this.$store);
};
core.ObservableObject = ObservableObject;
})(window.core);

35
src.old/js/core/should.js
View File

@@ -1,35 +0,0 @@
(function(){
"use strict";
var is = window.core.is;
window.core.should = {
beNumber: function (num, name) {
this.check(is.number(num), num + " is not a number");
this.check(isFinite(num), append(name, "is an infinite number"));
},
bePositiveInteger: function(num, name) {
this.beNumber(num);
this.check(num >= 0, append(name, "should be positive integer"));
},
notBeNull: function (obj, name) {
this.check(obj != null, append(name, "is null or undefined"));
},
beString: function(obj, name) {
this.check(typeof obj == "string", "should be a string");
},
check: function(assertion, message) {
if(assertion !== true) {
throw new Error (message);
}
}
};
function append(name, msg) {
return typeof name == "string" ? name + " " + msg : msg;
}
})();

72
src.old/js_unused/bindr.js
View File

@@ -1,72 +0,0 @@
(function(){
"use strict";
var bindr = {};
bindr.bindChildren = function(container, model) {
var elements = container.querySelectorAll('[data-bind]');
Array.prototype.call(elements, function(el){
});
};
bindr.bind = function(element, model, propertyName) {
};
bindr.attachView = function(viewElement, model) {
var elements = viewElement.querySelectorAll('[data-bindr]'),
count = elements.length,
i =0, el;
for(;i<count; i++){
el = elements[i];
this.bindElement(el, model, el.getAttribute('data-bindr'))
}
};
function bindInput(model, intput, propertyName) {
bindTextInput(intput, model, propertyName);
}
function bindCheckBox(element, model, propertyName) {
element.checked = model[propertyName];
element.addEventListener('changed', function (e) {
model[propertyName] = e.target.checked == true;
});
model.observe(propertyName, function (property, value) {
if (window.event && window.event.target == element) {
return;
}
element.checked = value;
});
}
function bindTextInput(input, model, propertyName) {
input.value = model[propertyName];
input.addEventListener('keyup', function (e) {
model[propertyName] = e.target.value;
});
model.observe(propertyName, function (property, value) {
if (window.event && window.event.target == input) {
return;
}
input.value = value;
});
}
function bindHtmlElement(model, el, propertyName) {
model.observe(propertyName, function(propery, value){
el.innerHTML = value;
});
}
window.core.bindr = bindr;
})();

57
src.old/js_unused/commandsFeature.js
View File

@@ -1,57 +0,0 @@
(function(app, core){
"use strict";
var should = core.should;
function Command(name) {
this.name = name;
this.executionHandlers = [];
}
Command.prototype.execute = function (cmdArgs) {
cmdArgs = cmdArgs || {};
cmdArgs.commandHandled = false;
for(var i=0; i<this.executionHandlers.length; i++) {
this.executionHandlers[i](cmdArgs);
if(cmdArgs.commandHandled === true) {
return;
}
}
};
Command.prototype.subscribe = function (handler) {
this.executionHandlers.push(handler);
// TODO: unsubcribe
};
app.commandHandlers = {};
app.command = function(name, handler) {
var cmd = this.commandHandlers[name];
if(cmd == null) {
cmd = this.commandHandlers[name] = new commandr.Command(name);
}
if(typeof handler == "function") {
cmd.subscribe(handler);
}
if (typeof handler == "object") {
if(typeof handler.execute != "function"){
console.warn('Given handler is an object, but doesn\'t have "execute" function');
return cmd;
}
this.di.resolveProperties(handler);
cmd.subscribe(handler.execute.bind(handler));
}
return cmd;
};
window.commandr = commandr;
})(window.app, window.core);

1
src/app/cmd.js
View File

@@ -66,6 +66,7 @@ var cmd = {
}
function invokeHandler (input, handler) {
var cmdResult = handler.handle({ input: input});
if(cmdResult != null) {
console.log(cmdResult);

22
src/app/commands.js
View File

@@ -11,14 +11,6 @@ var cmdConfig = {};
export default {
initialize (cmd, appState) {
cmd.command({
canHandle: (input) => expression.parser.canParse(input),
handle: function(c) {
var expr = expression.parser.parse(c.input);
appState.addCommandResult(new ExpressionResult(c.input, expr));
}
})
cmd.commands({
'help': function(c) {
appState.addCommandResult(new HelpResult(c.input));
@@ -44,9 +36,21 @@ export default {
'whatsnew': function(c) {
appState.addCommandResult(new WahtsnewResult(c.input));
},
'-notrack': function () {}
'-notrack': function () {},
'-debug': function() {
console.log('Debug mode on')
cmd.debugMode = true;
}
});
cmd.command({
canHandle: (input) => expression.parser.canParse(input),
handle: function(c) {
var expr = expression.parser.parse(c.input);
appState.addCommandResult(new ExpressionResult(c.input, expr));
}
})
// Last command handler reports that input is unknown
cmd.command({
canHandle: () => true,

1
src/app/components/InputBox.jsx
View File

@@ -33,7 +33,6 @@ export default class InputBox extends React.Component {
input.value = '';
cmd.execute(value);
console.log(this.history);
}
onKeyDown(args) {

2
src/app/components/results/ExpressionResultView.jsx
View File

@@ -19,8 +19,6 @@ export default class ExpressionResultView extends React.Component {
</div>
}
console.log('[BitwiseOperationExpressionView] render()', expr);
return <b>Expression: {expr.expressionString}</b>;
}
}

6
src/app/components/results/ListOfNumbersExpressionView.jsx
View File

@@ -27,12 +27,16 @@ class OperandView extends React.Component {
const binaryString = formatter.padLeft(op.bin, this.props.maxBitsLegnth, '0');
return <tr data-kind={op.kind}>
<td className="label">{op.input}</td>
<td className="label">{this.getLabel(op)}</td>
<td className="bin"><BinaryStringView emphasizeBytes={this.props.emphasizeBytes} binaryString={binaryString} allowFlipBits={true} onFlipBit={e => this.flipBit(e)} /></td>
<td className="other">{op.other}</td>
</tr>;
};
getLabel(op) {
return op.kind == 'bin' ? op.dec : op.input;
}
flipBit(index) {
var op = this.props.operand;
const binaryString = formatter.padLeft(op.bin, this.props.maxBitsLegnth, '0');

33
src/app/components/results/models/BitwiseExpressionViewModel.js
View File

@@ -41,19 +41,30 @@ export default class BitwiseExpressionViewModel {
addOperand(operand) {
this.maxNumberOfBits = Math.max(operand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign:'', label: operand.toString(), bin: operand.bin, other: operand.other, css: ''});
this.items.push({
sign:'',
label: this.getLabel(operand),
bin: operand.bin,
other: operand.other,
css: ''});
};
addExpression(expression) {
this.maxNumberOfBits = Math.max(expression.operand1.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign: expression.sign, label: expression.operand1.toString(), bin: expression.operand1.bin, other: expression.operand1.other, css: ''});
this.items.push({
sign: expression.sign,
label: this.getLabel(expression.operand1),
bin: expression.operand1.bin,
other: expression.operand1.other,
css: ''
});
};
addShiftExpressionResult(expression, resultOperand) {
this.maxNumberOfBits = Math.max(resultOperand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({
sign: expression.sign + expression.operand1.input,
label: resultOperand.toString(),
label: this.getLabel(resultOperand),
bin: resultOperand.bin,
other: resultOperand.other,
css: 'expression-result'});
@@ -61,9 +72,23 @@ export default class BitwiseExpressionViewModel {
addExpressionResult(operand) {
this.maxNumberOfBits = Math.max(operand.getLengthInBits(), this.maxNumberOfBits);
this.items.push({ sign:'=', label: operand.toString(), bin: operand.bin, other: operand.other, css: 'expression-result'});
this.items.push({
sign:'=',
label: this.getLabel(operand),
bin: operand.bin,
other: operand.other,
css: 'expression-result'});
};
getLabel (op) {
if(op.kind == 'bin') {
return op.dec;
}
return op.toString();
}
// TODO: move this method elsewhere. It is also used in LisOfNumbersExpressionView.js
static getNumberOfBits = function (bits, emphasizeBytes) {
if(emphasizeBytes && bits % 8 != 0) {

111
src/app/expression.js
View File

@@ -1,3 +1,5 @@
import Operand from './expression/operand';
var expression = {
factories:[],
canParse: function(string) {
@@ -25,7 +27,7 @@ var expression = {
return null;
},
parseOperand: function(input) {
return new Operand(input);
return Operand.parse(input);
},
createOperand: function(number, kind) {
return Operand.create(number, kind);
@@ -37,7 +39,7 @@ var expression = {
// List of numbers
expression.addFactory({
regex: /^(-?(?:\d+|0x[\d,a-f]+)\s?)+$/,
regex: /^(-?(?:\d+|0x[\d,a-f]+|0b[0-1])\s?)+$/,
canCreate: function(string) {
return this.regex.test(string);
},
@@ -48,7 +50,7 @@ var expression = {
input.split(' ').forEach(function(n){
if(n.trim().length > 0) {
numbers.push(new Operand(n.trim()));
numbers.push(Operand.parse(n.trim()));
}
});
@@ -58,13 +60,13 @@ var expression = {
// Not Expression
expression.addFactory({
regex: /^(~)(-?(?:\d+|0x[\d,a-f]+))$/,
regex: /^(~)(-?[b,x,a-f,0-9]+)$/,
canCreate: function(string) {
return this.regex.test(string);
},
create: function (string) {
var matches = this.regex.exec(string),
operand = new Operand(matches[2]);
operand = Operand.parse(matches[2]);
return new SingleOperandExpression(matches.input, operand, matches[1]);
}
@@ -72,8 +74,8 @@ var expression = {
// Multiple operands expression
expression.addFactory({
fullRegex: /^((<<|>>|>>>|\||\&|\^)?(-?((?:\d+(?!x))|(?:0x[\d,a-f]+))))+$/,
regex: /(<<|>>|>>>|\||\&|\^)?(-?((?:\d+(?!x))|(?:0x[\d,a-f]+)))/g,
fullRegex: /^((<<|>>|>>>|\||\&|\^)?(-?([b,x,a-f,0-9]+)))+$/,
regex: /(<<|>>|>>>|\||\&|\^)?(-?([b,x,a-f,0-9]+))/g,
canCreate: function(string) {
this.fullRegex.lastIndex = 0;
return this.fullRegex.test(this.normalizeString(string));
@@ -93,10 +95,11 @@ var expression = {
sign = m[1],
num = m[2];
var op = Operand.parse(num);
if(sign == null) {
return new Operand(num);
return op;
} else {
return new SingleOperandExpression(input, new Operand(num), sign);
return new SingleOperandExpression(input, op, sign);
}
},
normalizeString: function (string) {
@@ -104,91 +107,6 @@ var expression = {
}
});
// Represents numeric value
export class Operand {
constructor(input) {
this.input = input;
this.value = parseInt(input);
this.hex = Operand.toHexString(this.value.toString(16));
this.dec = this.value.toString(10);
// >>> 0 makes negative numbers like -1 to be displayed as '11111111111111111111111111111111' in binary instead of -1
this.bin = this.value < 0 ? (this.value >>> 0).toString(2) : this.value.toString(2);
this.kind = this.input.indexOf('0x') > -1 ? 'hex' : 'dec';
this.other = this.kind == 'dec' ? this.hex : this.dec;
this.lengthInBits = Operand.getBitLength(this.value);
}
getLengthInBits() {
if(this.value < 0) {
return 32;
}
return Math.floor(Math.log(this.value) / Math.log(2)) + 1;
};
getOtherKind(kind) {
switch(kind || this.kind) {
case 'dec': return 'hex';
case 'hex': return 'dec';
default : throw new Error(kind + " kind doesn't have opposite kind")
}
};
toString() {
return this.input;
}
setValue(value) {
console.log('Before ' + value, this);
this.value = value;
this.bin = Operand.toKindString(this.value, 'bin');
this.dec = Operand.toKindString(this.value, 'dec');
this.hex = Operand.toKindString(this.value, 'hex');
this.other = Operand.toKindString(this.value, this.getOtherKind());
this.input = Operand.toKindString(this.value, this.kind);
console.log('After ' + value, this);
}
static getBitLength(num) {
return Math.floor(Math.log(num) / Math.log(2)) + 1
}
static getBase(kind){
switch (kind){
case 'bin': return 2;
case 'hex': return 16;
case 'dec': return 10;
}
};
static create(number, kind) {
var str = number.toString(Operand.getBase(kind));
if(kind == 'hex') {
str = Operand.toHexString(str);
}
return new Operand(str);
};
static toKindString(value, kind) {
switch(kind) {
case 'hex':
var hexVal = Math.abs(value).toString(16);
return value >= 0 ? '0x' + hexVal : '-0x' + hexVal;
case 'bin':
return (value>>>0).toString(2);
case 'dec':
return value.toString(10);
default:
throw new Error("Unexpected kind: " + kind)
}
};
static toHexString (hex) {
return hex.indexOf('-') == 0 ? '-0x' + hex.substr(1) : '0x' + hex;
};
}
// Expressions like ~1
export class SingleOperandExpression {
constructor(expressionString, operand, sign) {
@@ -205,7 +123,10 @@ export class SingleOperandExpression {
str = value + this.sign + this.operand1.value
}
return Operand.create(eval(str), this.operand1.kind);
console.log('eval:' + str + " = " + eval(str), Operand.create(eval(str), this.operand1.kind));
const resultValue = eval(str);
return Operand.create(resultValue, this.operand1.kind);
};
isShiftExpression() {

5
src/app/expression/ExpressionError.js Normal file
View File

@@ -0,0 +1,5 @@
export default class ExpressionError extends Error {
constructor(message) {
super(message);
}
}

98
src/app/expression/Operand.js Normal file
View File

@@ -0,0 +1,98 @@
import numberParser from './numberParser';
import ExpressionError from './ExpressionError';
// Represents numeric value
export default class Operand {
constructor(cfg) {
this.input = cfg.input;
this.value = cfg.value;
this.kind = cfg.kind;
this.hex = Operand.toHexString(this.value.toString(16));
this.dec = this.value.toString(10);
// >>> 0 makes negative numbers like -1 to be displayed as '11111111111111111111111111111111' in binary instead of -1
this.bin = this.value < 0 ? (this.value >>> 0).toString(2) : this.value.toString(2);
this.other = this.kind == 'hex' ? this.dec : this.hex;
this.lengthInBits = Operand.getBitLength(this.value);
}
getLengthInBits() {
if(this.value < 0) {
return 32;
}
return Math.floor(Math.log(this.value) / Math.log(2)) + 1;
};
getOtherKind(kind) {
switch(kind || this.kind) {
case 'dec': return 'hex';
case 'hex': return 'dec';
default : throw new Error(kind + " kind doesn't have opposite kind")
}
};
toString() {
return this.input;
}
setValue(value) {
this.value = value;
this.bin = Operand.toKindString(this.value, 'bin');
this.dec = Operand.toKindString(this.value, 'dec');
this.hex = Operand.toKindString(this.value, 'hex');
this.other = Operand.toKindString(this.value, this.getOtherKind());
this.input = Operand.toKindString(this.value, this.kind);
}
static getBitLength(num) {
return Math.floor(Math.log(num) / Math.log(2)) + 1
}
static getBase(kind){
switch (kind){
case 'bin': return 2;
case 'hex': return 16;
case 'dec': return 10;
}
};
static create(value, kind) {
return new Operand({
value: value,
kind: kind,
input: Operand.toKindString(value, kind),
});
};
static parse(input) {
var parsed = numberParser.parse(input);
if(!parsed) {
throw new ExpressionError("Unknown number: " + input);
}
return new Operand(parsed);
}
static toKindString(value, kind) {
switch(kind) {
case 'hex':
var hexVal = Math.abs(value).toString(16);
return value >= 0 ? '0x' + hexVal : '-0x' + hexVal;
case 'bin':
return (value>>>0).toString(2);
case 'dec':
return value.toString(10);
default:
throw new Error("Unexpected kind: " + kind)
}
};
static toHexString (hex) {
return hex.indexOf('-') == 0 ? '-0x' + hex.substr(1) : '0x' + hex;
};
}

31
src/app/expression/numberParser.js Normal file
View File

@@ -0,0 +1,31 @@
var decimalRegex = /^-?\d+$/;
var hexRegex = /^-?0x[0-9,a-f]+$/i;
var binRegex = /^-?0b[0-1]+$/i;
var parsers = [
{ regex: decimalRegex, radix: 10, kind: 'dec', prefix: '^$' },
{ regex: hexRegex, radix: 16, kind: 'hex', prefix:/0x/i },
{ regex: binRegex, radix: 2, kind: 'bin', prefix:/0b/i }];
function applyParser(parser, rawInput) {
if(!parser.regex.test(rawInput)) {
return null;
}
var value = parseInt(rawInput.replace(parser.prefix, ''), parser.radix);
return {
value: value,
kind: parser.kind,
input: rawInput
}
}
var parser = {
parse: function(input) {
return parsers.map(p => applyParser(p, input)).reduce((c, n) => c || n);
}
}
export default parser;

6
src/app/hash.js
View File

@@ -11,12 +11,6 @@ export default {
args = { commands: [] };
splitHashList(decodedHash).forEach(function(value) {
// Support for -debur or -notrack properties
if(/^\-[a-zA-Z]+$/.test(value)) {
args[value.substr(1)] = true;
return;
}
args.commands.push(value);
});

2
src/app/index.jsx
View File

@@ -51,5 +51,7 @@ function executeStartupCommands() {
startupCommands = hashArgs.commands;
}
log.info('starup commands', startupCommands);
startupCommands.forEach(cmd.execute.bind(cmd));
}

4
src/css/styles.css
View File

@@ -108,8 +108,8 @@ code { font-size: 1.2em; font-weight: bold; }
.midnight .zero { color: #85a0ad;}
.midnight .prefix { color: #85a0ad}
.midnight .other { color: #9FBAC7;}
.midnight .hashLink, .dark .hashLink:visited { color: #333 }
.midnight .hashLink:hover { color: #85a0ad }
.midnight .hashLink, .dark .hashLink:visited { color: #85a0ad }
.midnight .hashLink:hover { color: #9FBAC7 }
.midnight ul.top-links li:hover { background: #132537 }
.midnight .error { color:#da586d}

27
tests/e2e/spec.js
View File

@@ -32,6 +32,7 @@ describe('when application starts', function() {
.then(function() { return sutPage.executeExpression('1')})
.then(function() { return sutPage.executeExpression('1|2')})
.then(function() { return sutPage.executeExpression('1^2')})
.then(function() { return sutPage.executeExpression('1^0b10')})
.then(function() { return sutPage.executeExpression('0x1>>>0xf')})
.then(function() { return sutPage.executeExpression('0x1 0xf')})
.then(function() { return sutPage.executeExpression('0x1 | 0xf')})
@@ -43,13 +44,10 @@ describe('when application starts', function() {
});
it('should execute list of numbers', function() {
sutPage.executeExpression('3 0xf')
.then(function() { return sutPage.shouldHaveNoErrors(); })
.then(function() {
return assertExpressionResult(
[{ label: '3', bin:'00000011', other: '0x3'},
{ label: '0xf', bin:'00001111', other: '15'}])
});
assertOperation('3 0xf 0b101',
[{ label: '3', bin:'00000011', other: '0x3'},
{ label: '0xf', bin:'00001111', other: '15'},
{ label: '5', bin: '00000101', other: '0x5' }]);
});
it('should do a shift operation', function() {
@@ -111,13 +109,13 @@ describe('when application starts', function() {
])
});
it('should do XOR or large numbers', function() {
return assertOperation('0x0001000000003003^0x3001800400000fc1',
[{ label: '0x0001000000003003', bin:'0000000000000001000000000000000000000000000000000011000000000011', other: '281474976722947'},
{ sign:'^', label: '0x3001800400000fc1', bin:'0011000000000001100000000000010000000000000000000001000000000000', other: '3459186743465480000'},
{ sign:'=', label: '0x2003', bin:'0000000000000000000000000000000000000000000000000010000000000011', other: '8195'}])
});
it('should do or for binary numbers', function() {
return assertOperation('0b10|0b11',
[{ label: "2", bin: "00000010", other: "0x2" },
{ sign: "|", label: "3", bin: "00000011", other: "0x3" },
{ sign: "=", label: "3", bin: "00000011", other: '0x3'}]
);
})
it('should do prefer hex result', function() {
@@ -202,6 +200,7 @@ function assertExpressionResult(expected) {
}
function assertOperation(op, expected) {
console.log('\n' + op);
return sutPage.executeExpression(op)
.then(function() { return sutPage.shouldHaveNoErrors(); })
.then(function() {

30
tests/unit/expressionSpec.js
View File

@@ -30,20 +30,24 @@ describe("expression parser", function() {
console.log('case: ' + input);
var actual = parser.parse(input);
var expected = expressionCases[input];
expect(actual).toBeDefined();
expect(actual).not.toBe(null);
expect(actual.sign).toBe(expected.sign);
expect(actual.operand1.value).toBe(expected.operand1);
if(expected.operand2 != null) {
expect(actual.operand2.value).toBe(expected.operand2);
}
else
{
expect(actual.operand2).not.toBeDefined();
}
expect(actual.expressionString).toBe(expected.string);
console.log(actual.toString());
console.log('actual:' + actual.toString());
// expect(actual).toBeDefined();
// expect(actual).not.toBe(null);
// expect(actual.sign).toBe(expected.sign);
// expect(actual.operand1.value).toBe(expected.operand1);
// if(expected.operand2 != null) {
// expect(actual.operand2.value).toBe(expected.operand2);
// }
// else
// {
// expect(actual.operand2).not.toBeDefined();
// }
// expect(actual.expressionString).toBe(expected.string);
// console.log(actual.toString());
}
});

18
tests/unit/operandSpec.js Normal file
View File

@@ -0,0 +1,18 @@
var expression = require('../../src/app/expression');
var parser = expression.parser;
describe("operand", function() {
it("should be able to create opearand from positive binary string", function() {
var input = "0b10";
var op = new expression.Operand(input);
expect(op.value).toBe(2);
expect(op.kind).toBe('dec');
});
it("should be able to create opearand from negative binary string", function() {
var input = "-0b10";
var op = new expression.Operand(input);
expect(op.value).toBe(-2);
expect(op.kind).toBe('dec');
})
});

18
tests/unit/parserSpec.js
View File

@@ -1,11 +1,11 @@
var expression = require('../../src/app/expression');
var parser = new expression.Parser();
// var expression = require('../../src/app/expression');
// var parser = new expression.Parser();
describe("Parser", function() {
// describe("Parser", function() {
it("should be able to parse from start", function() {
var sut = new expression.Parser("test", 0);
sut.parse();
console.log(sut);
});
});
// it("should be able to parse from start", function() {
// var sut = new expression.Parser("test", 0);
// sut.parse();
// console.log(sut);
// });
// });