public void TestRewriteChildren()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var rewritten = expr.RewriteChildren(_ => new Lit(3));
Assert.Equal(6, Eval(rewritten));
}
{
var result = expr.RewriteChildren(x => x);
Assert.Same(expr, result);
}
}
public async ValueTask TestRewriteChildrenAsync()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var rewritten = await expr.RewriteChildren(_ => ValueTask.FromResult((Expr) new Lit(3)));
Assert.Equal(6, Eval(rewritten));
}
{
var result = await expr.RewriteChildren(x => ValueTask.FromResult(x));
Assert.Same(expr, result);
}
}
public Type Visit(Neg node) //also for substraction?
{
if (node[1] != null) //two operands -> substraction
{
VisitBinaryOperator("-", node, Type.INT);
}
else //one operand -> negation
{
if (Visit((dynamic)node[0]) != Type.INT)
{
throw new SemanticError(
String.Format(
"Operator - requires one operand of type {1}",
Type.INT),
node.AnchorToken);
}
}
return(Type.INT);
}
public async ValueTask TestZipFoldAsync()
{
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
var expr = new Add(one, minusTwo);
Assert.True(await EqualAsync(expr, expr));
}
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
var left = new Add(one, minusTwo);
var right = new Add(two, minusTwo);
Assert.False(await EqualAsync(left, right));
}
}
public double Analyze(string s)
{
var score = 0;
var wc = 0;
foreach (var w in s.Split('\n', '\r', '-', '=', '(', ')', ' ', '\t', '!', '.', ',', '?', '"', '\''))
{
var ww = w.ToLower();
if (Pos.Contains(ww))
{
score++;
}
if (Neg.Contains(ww))
{
score--;
}
wc++;
}
return(1 / (1 + Math.Exp(-Sensitivity * (score + Bias) / wc)));
}
public void TestZipFold()
{
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
var expr = new Add(one, minusTwo);
Assert.True(Equal(expr, expr));
}
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
var left = new Add(one, minusTwo);
var right = new Add(two, minusTwo);
Assert.False(Equal(left, right));
}
}
private void button1_Click(object sender, EventArgs e)
{
string password = codifica_MD5(detallePassWord.Text);
if (Modo == 'm')
{
//if (Neg.modificar(Usu.UsuarioID, detalleEmail.Text, detalleNombre.Text,
// password, detalleApe.Text, detalleDNI2.Text, detalleTel.Text,
// detalleCalle.Text, "", detalleCP.Text, Usu.PuebloID, Usu.ProvinciaID, detalleNacido.Text))
if (Neg.modificar(Usu))
{
statusStrip1.Visible = true;
toolStripStatusLabel1.Visible = true;
toolStripStatusLabel1.Text = "Usuario modificado";
}
else
{
statusStrip1.Visible = true;
toolStripStatusLabel1.Visible = true;
toolStripStatusLabel1.Text = "Error al modificar el usuario";
}
}
else
if (Modo == 'i')
{
if (Neg.insertar(detalleEmail.Text, detalleNombre.Text,
password, detalleApe.Text, detalleDNI.Text, detalleTel.Text,
detalleCalle.Text, "", detalleCP.Text, "2331", "46", detalleNacido.Text))
{
statusStrip1.Visible = true;
toolStripStatusLabel1.Visible = true;
toolStripStatusLabel1.Text = "Usuario creado";
}
else
{
statusStrip1.Visible = true;
toolStripStatusLabel1.Visible = true;
toolStripStatusLabel1.Text = "Error al crear usuario";
}
}
}
public bool TryGenerate(Function fuction, int block_id, Opcode op, IOperand[] oprands, out IOperand result)
{
result = Variable.GetTemporary();
Instruction instruction;
switch (op)
{
case Opcode.Neg: {
instruction = new Neg(oprands[0]);
break;
}
case Opcode.Add: {
instruction = new Add(oprands[0], oprands[1]);
break;
}
case Opcode.Sub: {
instruction = new Sub(oprands[0], oprands[1]);
break;
}
case Opcode.Mul: {
instruction = new Mul(oprands[0], oprands[1]);
break;
}
case Opcode.Div: {
instruction = new Div(oprands[0], oprands[1]);
break;
}
default:
return(false);
}
// Function.Instructions.Add(instruction);
// Function.Results.Add(result);
// Blocks[block_id].AppendInstruction(Instructions.Length() - 1);
return(true);
}
public void TestDescendantAt()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var result = expr.DescendantAt(new[] { Direction.Down, Direction.Right });
Assert.Same(minusTwo, result);
}
{
var result = expr.DescendantAt(Array.Empty <Direction>());
Assert.Same(expr, result);
}
{
Assert.Throws <InvalidOperationException>(() => expr.DescendantAt(new[] { Direction.Down, Direction.Left }));
Assert.Throws <InvalidOperationException>(() => expr.DescendantAt(new[] { Direction.Right }));
Assert.Throws <InvalidOperationException>(() => expr.DescendantAt(new[] { Direction.Up }));
}
}
public void TestReplaceDescendantAt()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var result = expr.ReplaceDescendantAt(new[] { Direction.Down, Direction.Right }, one);
Assert.Equal(2, Eval(result));
}
{
var result = expr.ReplaceDescendantAt(new[] { Direction.Down, Direction.Right }, minusTwo);
Assert.Same(expr, result);
}
{
Assert.Throws <InvalidOperationException>(() => expr.ReplaceDescendantAt(new[] { Direction.Down, Direction.Left }, one));
Assert.Throws <InvalidOperationException>(() => expr.ReplaceDescendantAt(new[] { Direction.Right }, one));
Assert.Throws <InvalidOperationException>(() => expr.ReplaceDescendantAt(new[] { Direction.Up }, one));
}
}
public void TestRewriteDescendantAt()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var result = expr.RewriteDescendantAt(new[] { Direction.Down }, x => x is Lit l ? new Lit(l.Value + 1) : x);
Assert.Equal(0, Eval(result));
}
{
var result = expr.RewriteDescendantAt(new[] { Direction.Down }, x => x);
Assert.Same(expr, result);
}
{
Assert.Throws <InvalidOperationException>(() => expr.RewriteDescendantAt(new[] { Direction.Down, Direction.Left }, x => x));
Assert.Throws <InvalidOperationException>(() => expr.RewriteDescendantAt(new[] { Direction.Right }, x => x));
Assert.Throws <InvalidOperationException>(() => expr.RewriteDescendantAt(new[] { Direction.Up }, x => x));
}
}
public async ValueTask TestRewriteDescendantAtAsync()
{
var one = new Lit(1);
var two = new Lit(2);
var minusTwo = new Neg(two);
Expr expr = new Add(one, minusTwo);
{
var result = await expr.RewriteDescendantAt(
new[] { Direction.Down },
x => ValueTask.FromResult(x is Lit l ? new Lit(l.Value + 1) : x)
);
Assert.Equal(0, Eval(result));
}
{
var result = await expr.RewriteDescendantAt(
new[] { Direction.Down },
x => ValueTask.FromResult(x)
);
Assert.Same(expr, result);
}
{
await Assert.ThrowsAsync <InvalidOperationException>(async() => await expr.RewriteDescendantAt(
new[] { Direction.Down, Direction.Left },
x => ValueTask.FromResult(x)
));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await expr.RewriteDescendantAt(
new[] { Direction.Right },
x => ValueTask.FromResult(x)
));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await expr.RewriteDescendantAt(
new[] { Direction.Up },
x => ValueTask.FromResult(x)
));
}
}
private PLS CreateExpression(int size)
{
PLS predicate = CreateUnaryExpression();
int sizeLeft = size;
if (sizeLeft > 0)
{
int j = Random.Range(0, 4);
PLS newExp = CreateExpression(sizeLeft - 1);
switch (j)
{
case 0:
predicate = new And(predicate, newExp);
break;
case 1:
predicate = new Or(predicate, newExp);
break;
case 2:
predicate = new To(predicate, newExp);
break;
case 3:
predicate = new Equiv(predicate, newExp);
break;
}
}
int i = Random.Range(0, 2);
if (i > 0)
{
predicate = new Neg(predicate);
}
return(predicate);
}
//-----------------------------------------------------------
public string Visit(Neg node)
{
return("\t\tldc.i4.0\n\t\t" + Visit((dynamic)node[0]) + "\n\t\tsub.ov\n");
}
//This function actually creates the object associated with each Instruction by using a long switch statement. The object
//created is polymorphed up to an IInstruction and then returned from the function to be stored in the encodedInstrs list.
//Ugly? Very. Effective? Extremely.
private IInstruction createObject(string comm, int valToUse, int currentInstruc)
{
IInstruction retVal = null;
switch (comm)
{
case "exit":
retVal = new Exit(valToUse) as IInstruction;
break;
case "swap":
retVal = new Swap() as IInstruction;
break;
case "inpt":
retVal = new Inpt() as IInstruction;
break;
case "nop":
retVal = new Nop() as IInstruction;
break;
case "pop":
retVal = new Pop() as IInstruction;
break;
case "add":
retVal = new Add() as IInstruction;
break;
case "sub":
retVal = new Sub() as IInstruction;
break;
case "mul":
retVal = new Mul() as IInstruction;
break;
case "div":
retVal = new Div() as IInstruction;
break;
case "rem":
retVal = new Rem() as IInstruction;
break;
case "and":
retVal = new And() as IInstruction;
break;
case "or":
retVal = new Or() as IInstruction;
break;
case "xor":
retVal = new Xor() as IInstruction;
break;
case "neg":
retVal = new Neg() as IInstruction;
break;
case "not":
retVal = new Not() as IInstruction;
break;
case "goto":
retVal = new Goto(valToUse) as IInstruction;
break;
case "ifeq":
retVal = new If1(0, valToUse, currentInstruc) as IInstruction;
break;
case "ifne":
retVal = new If1(1, valToUse, currentInstruc) as IInstruction;
break;
case "iflt":
retVal = new If1(2, valToUse, currentInstruc) as IInstruction;
break;
case "ifgt":
retVal = new If1(3, valToUse, currentInstruc) as IInstruction;
break;
case "ifle":
retVal = new If1(4, valToUse, currentInstruc) as IInstruction;
break;
case "ifge":
retVal = new If1(5, valToUse, currentInstruc) as IInstruction;
break;
case "ifez":
retVal = new If2(0, valToUse, currentInstruc) as IInstruction;
break;
case "ifnz":
retVal = new If2(1, valToUse, currentInstruc) as IInstruction;
break;
case "ifmi":
retVal = new If2(2, valToUse, currentInstruc) as IInstruction;
break;
case "ifpl":
retVal = new If2(3, valToUse, currentInstruc) as IInstruction;
break;
case "dup":
retVal = new Dup(valToUse) as IInstruction;
break;
case "print":
retVal = new Print() as IInstruction;
break;
case "dump":
retVal = new Dump() as IInstruction;
break;
case "push":
retVal = new Push(valToUse) as IInstruction;
break;
}
return(retVal);
}
public LoginForm()
{
InitializeComponent();
neg = new Neg();
}
private Node group0() {
boolean capturingGroup = false;
Node head = null;
Node tail = null;
int save = _flags;
root = null;
int ch = next();
if (ch == '?') {
ch = skip();
switch (ch) {
case ':': // (?:xxx) pure group
head = createGroup(true);
tail = root;
head.next = expr(tail);
break;
case '=': // (?=xxx) and (?!xxx) lookahead
case '!':
head = createGroup(true);
tail = root;
head.next = expr(tail);
if (ch == '=') {
head = tail = new Pos(head);
} else {
head = tail = new Neg(head);
}
break;
case '>': // (?>xxx) independent group
head = createGroup(true);
tail = root;
head.next = expr(tail);
head = tail = new Ques(head, INDEPENDENT);
break;
case '<': // (?<xxx) look behind
ch = read();
if (ASCII.isLower(ch) || ASCII.isUpper(ch)) {
// named captured group
String name = groupname(ch);
if (namedGroups().containsKey(name))
throw error(new String("Named capturing group <" + name
+ "> is already defined"));
capturingGroup = true;
head = createGroup(false);
tail = root;
namedGroups().put(name, new Integer(capturingGroupCount-1));
head.next = expr(tail);
break;
}
int start = _cursor;
head = createGroup(true);
tail = root;
head.next = expr(tail);
tail.next = lookbehindEnd;
TreeInfo info = new TreeInfo();
head.study(info);
if (info.maxValid == false) {
throw error(new String("Look-behind group does not have "
+ "an obvious maximum length"));
}
boolean hasSupplementary = findSupplementary(start, patternLength);
if (ch == '=') {
head = tail = (hasSupplementary ?
new BehindS(head, info.maxLength,
info.minLength) :
new Behind(head, info.maxLength,
info.minLength));
} else if (ch == '!') {
head = tail = (hasSupplementary ?
new NotBehindS(head, info.maxLength,
info.minLength) :
new NotBehind(head, info.maxLength,
info.minLength));
} else {
throw error(new String("Unknown look-behind group"));
}
break;
case '$':
case '@':
throw error(new String("Unknown group type"));
default: // (?xxx:) inlined match flags
unread();
addFlag();
ch = read();
if (ch == ')') {
return null; // Inline modifier only
}
if (ch != ':') {
throw error(new String("Unknown inline modifier"));
}
head = createGroup(true);
tail = root;
head.next = expr(tail);
break;
}
} else { // (xxx) a regular group
capturingGroup = true;
head = createGroup(false);
tail = root;
head.next = expr(tail);
}
accept(')', new String("Unclosed group"));
_flags = save;
// Check for quantifiers
Node node = closure(head);
if (node == head) { // No closure
root = tail;
return node; // Dual return
}
if (head == tail) { // Zero length assertion
root = node;
return node; // Dual return
}
if (node is Ques) {
Ques ques = (Ques) node;
if (ques.type == POSSESSIVE) {
root = node;
return node;
}
tail.next = new BranchConn();
tail = tail.next;
if (ques.type == GREEDY) {
head = new Branch(head, null, tail);
} else { // Reluctant quantifier
head = new Branch(null, head, tail);
}
root = tail;
return head;
} else if (node is Curly) {
Curly curly = (Curly) node;
if (curly.type == POSSESSIVE) {
root = node;
return node;
}
// Discover if the group is deterministic
TreeInfo info = new TreeInfo();
if (head.study(info)) { // Deterministic
GroupTail temp = (GroupTail) tail;
head = root = new GroupCurly(head.next, curly.cmin,
curly.cmax, curly.type,
((GroupTail)tail).localIndex,
((GroupTail)tail).groupIndex,
capturingGroup);
return head;
} else { // Non-deterministic
int temp = ((GroupHead) head).localIndex;
Loop loop;
if (curly.type == GREEDY)
loop = new Loop(this.localCount, temp);
else // Reluctant Curly
loop = new LazyLoop(this.localCount, temp);
Prolog prolog = new Prolog(loop);
this.localCount += 1;
loop.cmin = curly.cmin;
loop.cmax = curly.cmax;
loop.body = head;
tail.next = loop;
root = loop;
return prolog; // Dual return
}
}
throw error(new String("Internal logic error"));
}
// builds node - constants, unary operators and binary operators
private List <ISyntaxNode> BuildListSyntaxNode(string function)
{
List <ISyntaxNode> listNode = new List <ISyntaxNode>();
for (int i = 0; i < function.Length; i++)
{
if (function[i] == 'p')
{
ISyntaxNode pi = new Var(Math.PI);
listNode.Add(pi);
i++;
}
if (function[i] == 'e')
{
ISyntaxNode e = new Var(Math.E);
listNode.Add(e);
}
if (function[i] == 'x')
{
ISyntaxNode x = new X();
listNode.Add(x);
}
if (Char.IsNumber(function[i]))
{
ISyntaxNode var = ReadVar(function, i, out i);
listNode.Add(var);
}
if (function[i] == '-')
{
if (i == 0 || function[i - 1] == '(' || function[i + 1] == '(')
{
ISyntaxNode op = new Neg();
listNode.Add(op);
continue;
}
}
if (MyChar.IsBinaryOperation(function[i]))
{
ISyntaxNode op = ReadOperation(function, i, out i);
listNode.Add(op);
}
if (function[i] == '(')
{
ISyntaxNode op = new OpenBrackets();
listNode.Add(op);
}
if (function[i] == ')')
{
ISyntaxNode op = new CloseBrackets();
listNode.Add(op);
}
if (function[i] == 's' || function[i] == 'c' || function[i] == 't' ||
function[i] == 'l' || function[i] == 'a')
{
ISyntaxNode func = ReadFunction(function, i, out i);
listNode.Add(func);
}
}
return(listNode);
}
//-----------------------------------------------------------
public void Visit(Neg node)
{
VisitChildren(node);
}
static void Main(string[] args)
{
RunConfig runConfig;
if (!TryParseArguments(args, out runConfig))
{
Usage();
return;
}
var code = File.ReadAllText(args[0]);
var pageState = new GraphicsState();
var stack = new LinearList <IOperation>();
var execStack = new LinearList <IOperation>();
var dictStack = new LinearList <IDictionary <string, IOperation> >();
var system = new Dictionary <string, IOperation>();
system["add"] = new Add();
system["sub"] = new Substract();
system["mul"] = new Multiplicate();
system["div"] = new Divide();
system["mod"] = new Mod();
system["def"] = new Define();
system["for"] = new For();
system["dup"] = new Duplicate();
system["index"] = new Index();
system["pop"] = new Pop();
system["exch"] = new Exchange();
system["repeat"] = new Repeat();
system["array"] = new EmptyArray();
system["astore"] = new LoadArray();
system["rand"] = new Rand();
system["cvi"] = new ConvertToInteger();
system["copy"] = new Copy();
system["roll"] = new Roll();
system["get"] = new ArrayGet();
system["put"] = new ArrayPut();
system["ne"] = new NotEqual();
system["eq"] = new Equal();
system["or"] = new Or();
system["ifelse"] = new IfElse();
system["if"] = new If();
system["neg"] = new Neg();
system["not"] = new Not();
system["sqrt"] = new Sqrt();
system["lt"] = new LessThan();
system["ge"] = new GreaterOrEqualThan();
dictStack.Push(system);
var graphics = new Dictionary <string, IOperation>();
graphics["newpath"] = new NewPath(pageState);
graphics["closepath"] = new ClosePath(pageState);
graphics["fillpath"] = new FillPath(pageState);
graphics["setgray"] = new SetGray(pageState);
graphics["setrgbcolor"] = new SetRGB(pageState);
graphics["setlinewidth"] = new SetLineWidth(pageState);
graphics["fill"] = new FillPath(pageState);
graphics["showpage"] = new ShowPage(pageState);
graphics["moveto"] = new MoveTo(pageState);
graphics["lineto"] = new LineTo(pageState);
graphics["rlineto"] = new RelativeLineTo(pageState);
graphics["gsave"] = new SaveGraphicsState(pageState);
graphics["grestore"] = new RestoreGraphicsState(pageState);
graphics["stroke"] = new StrokePath(pageState);
graphics["curveto"] = new CurveTo(pageState);
graphics["arc"] = new Arc(pageState);
dictStack.Push(graphics);
dictStack.Push(new Dictionary <string, IOperation>());
//execStack.Push(start);
CodeParser.LoadCode(execStack,
@"
/findfont { pop (somefont) } def
/scalefont { exch pop } def
/setfont { pop } def
/setlinecap { pop } def
/srand { pop } def
");
CodeParser.LoadCode(execStack, code);
var state = new PreScriptState(stack, execStack, dictStack);
while (execStack.Count > 0)
{
var operation = execStack.Pop();
operation.Process(state);
}
}
public static Scalar <Type> operator -(Scalar <Type> x) => Neg <Type> .Create(x);
