public override void Compile(ICompiler cmp, bool reverse)
{
int gid = group.Number;
LinkRef tail = cmp.NewLink();
if (FalseExpression == null)
{
// IfDefined :1
// <yes_exp>
// 1: <tail>
cmp.EmitIfDefined(gid, tail);
TrueExpression.Compile(cmp, reverse);
}
else
{
// IfDefined :1
// <yes_expr>
// Jump :2
// 1: <no_expr>
// 2: <tail>
LinkRef false_expr = cmp.NewLink();
cmp.EmitIfDefined(gid, false_expr);
TrueExpression.Compile(cmp, reverse);
cmp.EmitJump(tail);
cmp.ResolveLink(false_expr);
FalseExpression.Compile(cmp, reverse);
}
cmp.ResolveLink(tail);
}
public override void Compile(ICompiler cmp, bool reverse)
{
// can't invoke Group.Compile from here :(
// so I'll just repeat the code
LinkRef tail = cmp.NewLink();
cmp.EmitBalanceStart(this.Number, balance.Number, this.IsNamed, tail);
int count = Expressions.Count;
for (int i = 0; i < count; ++i)
{
Expression e;
if (reverse)
{
e = Expressions[count - i - 1];
}
else
{
e = Expressions[i];
}
e.Compile(cmp, reverse);
}
cmp.EmitBalance();
cmp.ResolveLink(tail);
}
public override void Compile(ICompiler cmp, bool reverse)
{
if (group == null)
{
Alternate.Compile(cmp, reverse);
return;
}
int index = group.Index;
LinkRef linkRef = cmp.NewLink();
if (base.FalseExpression == null)
{
cmp.EmitIfDefined(index, linkRef);
base.TrueExpression.Compile(cmp, reverse);
}
else
{
LinkRef linkRef2 = cmp.NewLink();
cmp.EmitIfDefined(index, linkRef2);
base.TrueExpression.Compile(cmp, reverse);
cmp.EmitJump(linkRef);
cmp.ResolveLink(linkRef2);
base.FalseExpression.Compile(cmp, reverse);
}
cmp.ResolveLink(linkRef);
}
public PackageRef(string[] titles, string[] urls)
{
Links = new LinkRef[titles.Length];
for (int i = 0; i < titles.Length; i++)
{
Links[i] = new LinkRef(titles[i], urls[i]);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef tail = cmp.NewLink();
cmp.EmitSub(tail);
base.Compile(cmp, reverse);
cmp.EmitTrue();
cmp.ResolveLink(tail);
}
protected override void OnPreRender(EventArgs e)
{
this.CssClass = "ratingStarBlock";
if (this.UserRef != null)
{
this.CssClass += " userActive";
registerScripts();
}
for (int i = 1; i <= NumberOfStars; i++)
{
HtmlGenericControl starContainer = new HtmlGenericControl("div");
HtmlGenericControl starLink = new HtmlGenericControl("a");
starContainer.Attributes.Add("class", "star");
starLink.Attributes.Add("href", "#" + i.ToString());
if (Rating >= i)
{
starLink.Style.Add("width", "100%");
starContainer.Attributes["class"] += " on";
}
else if (Math.Ceiling(Rating) == i)
{
int percentage = Convert.ToInt32(Math.Round((Rating - Math.Floor(Rating)) * 100, 0));
starLink.Style.Add("width", percentage + "%");
starContainer.Attributes["class"] += " on";
}
else
{
starLink.Style.Add("width", "100%");
}
if (this.UserRef != null)
{
starLink.Attributes.Add("onclick", "CuplexService.RateLink(" + LinkRef.ToString() + "," + i.ToString() + ",RateLinkCallback); return false;");
if (!HasVoted)
{
starLink.Attributes.Add("title", i.ToString() + " av 5");
}
}
else
{
starLink.Attributes.Add("onclick", "return false");
}
if (this.UserRef == null || HasVoted)
{
starContainer.Attributes["class"] += " done";
}
starContainer.Controls.Add(starLink);
this.Controls.Add(starContainer);
}
this.Attributes.Add("title", Math.Round(Rating, 2).ToString() + " av 5");
}
//PM_REFACTOR 2011-08-12
//****************************************************************************
//* <placeholder for header> *
//****************************************************************************
private void fillInAndGenerate(string aLinkText, string aLink,
LinkRef aLinkRefGenerator)
{
//Direct manipulation of GUI elements. Is it proper??
//Direct fill into the GUI. Is this a bad idea?
txtLinkText.Text = aLinkText;
txtURL.Text = aLink;
txtRefNumber.Text = aLinkRefGenerator.GetRef();
generate();
}
//****************************************************************************
//* <placeholder for header> *
//****************************************************************************
public frmMarkdown(string aTerm, string aURL, LinkRef aLinkRefGenerator)
{
InitializeComponent();
mTerm2 = aTerm;
mURL2 = aURL;
mLinkRefGenerator = aLinkRefGenerator;
mURLparseInfo = new Dictionary <string, URLparseInfoStruct>(2);
addURLparseInfo("wikipedia.org/wiki", "wikipedia:");
addURLparseInfo("wiktionary.org/wiki", "wiktionary:");
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef linkRef = cmp.NewLink();
cmp.EmitBalanceStart(base.Index, balance.Index, base.IsNamed, linkRef);
int count = base.Expressions.Count;
for (int i = 0; i < count; i++)
{
Expression expression = (!reverse) ? base.Expressions[i] : base.Expressions[count - i - 1];
expression.Compile(cmp, reverse);
}
cmp.EmitBalance();
cmp.ResolveLink(linkRef);
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef linkRef = cmp.NewLink();
foreach (Expression alternative in Alternatives)
{
LinkRef linkRef2 = cmp.NewLink();
cmp.EmitBranch(linkRef2);
alternative.Compile(cmp, reverse);
cmp.EmitJump(linkRef);
cmp.ResolveLink(linkRef2);
cmp.EmitBranchEnd();
}
cmp.EmitFalse();
cmp.ResolveLink(linkRef);
cmp.EmitAlternationEnd();
}
public override void Compile(ICompiler cmp, bool reverse)
{
if (this.Expression.IsComplex())
{
LinkRef linkRef = cmp.NewLink();
cmp.EmitRepeat(this.min, this.max, this.lazy, linkRef);
this.Expression.Compile(cmp, reverse);
cmp.EmitUntil(linkRef);
}
else
{
LinkRef linkRef2 = cmp.NewLink();
cmp.EmitFastRepeat(this.min, this.max, this.lazy, linkRef2);
this.Expression.Compile(cmp, reverse);
cmp.EmitTrue();
cmp.ResolveLink(linkRef2);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef linkRef = cmp.NewLink();
foreach (object obj in this.Alternatives)
{
Expression expression = (Expression)obj;
LinkRef linkRef2 = cmp.NewLink();
cmp.EmitBranch(linkRef2);
expression.Compile(cmp, reverse);
cmp.EmitJump(linkRef);
cmp.ResolveLink(linkRef2);
cmp.EmitBranchEnd();
}
cmp.EmitFalse();
cmp.ResolveLink(linkRef);
cmp.EmitAlternationEnd();
}
public override void Compile(ICompiler cmp, bool reverse)
{
// LinkRef next = cmp.NewLink ();
LinkRef tail = cmp.NewLink();
foreach (Expression e in Alternatives)
{
LinkRef next = cmp.NewLink();
cmp.EmitBranch(next);
e.Compile(cmp, reverse);
cmp.EmitJump(tail);
cmp.ResolveLink(next);
cmp.EmitBranchEnd();
}
cmp.EmitFalse();
cmp.ResolveLink(tail);
cmp.EmitAlternationEnd();
}
public override void Compile(ICompiler cmp, bool reverse)
{
if (Expression.IsComplex())
{
LinkRef until = cmp.NewLink();
cmp.EmitRepeat(min, max, lazy, until);
Expression.Compile(cmp, reverse);
cmp.EmitUntil(until);
}
else
{
LinkRef tail = cmp.NewLink();
cmp.EmitFastRepeat(min, max, lazy, tail);
Expression.Compile(cmp, reverse);
cmp.EmitTrue();
cmp.ResolveLink(tail);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
GetWidth(out int min, out int max);
cmp.EmitInfo(group_count, min, max);
AnchorInfo anchorInfo = GetAnchorInfo(reverse);
LinkRef linkRef = cmp.NewLink();
cmp.EmitAnchor(reverse, anchorInfo.Offset, linkRef);
if (anchorInfo.IsPosition)
{
cmp.EmitPosition(anchorInfo.Position);
}
else if (anchorInfo.IsSubstring)
{
cmp.EmitString(anchorInfo.Substring, anchorInfo.IgnoreCase, reverse);
}
cmp.EmitTrue();
cmp.ResolveLink(linkRef);
base.Compile(cmp, reverse);
cmp.EmitTrue();
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef linkRef = cmp.NewLink();
LinkRef linkRef2 = cmp.NewLink();
if (!this.negate)
{
cmp.EmitTest(linkRef, linkRef2);
}
else
{
cmp.EmitTest(linkRef2, linkRef);
}
this.TestExpression.Compile(cmp, this.reverse);
cmp.EmitTrue();
if (base.TrueExpression == null)
{
cmp.ResolveLink(linkRef2);
cmp.EmitFalse();
cmp.ResolveLink(linkRef);
}
else
{
cmp.ResolveLink(linkRef);
base.TrueExpression.Compile(cmp, reverse);
if (base.FalseExpression == null)
{
cmp.ResolveLink(linkRef2);
}
else
{
LinkRef linkRef3 = cmp.NewLink();
cmp.EmitJump(linkRef3);
cmp.ResolveLink(linkRef2);
base.FalseExpression.Compile(cmp, reverse);
cmp.ResolveLink(linkRef3);
}
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
// info block
int min, max;
GetWidth(out min, out max);
cmp.EmitInfo(group_count, min, max);
// anchoring expression
AnchorInfo info = GetAnchorInfo(reverse);
//if (reverse)
// info = new AnchorInfo (this, GetFixedWidth ()); // FIXME
LinkRef pattern = cmp.NewLink();
cmp.EmitAnchor(reverse, info.Offset, pattern);
if (info.IsPosition)
{
cmp.EmitPosition(info.Position);
}
else if (info.IsSubstring)
{
cmp.EmitString(info.Substring, info.IgnoreCase, reverse);
}
cmp.EmitTrue();
// pattern
cmp.ResolveLink(pattern);
base.Compile(cmp, reverse);
cmp.EmitTrue();
}
public override void Compile(ICompiler cmp, bool reverse)
{
LinkRef true_expr = cmp.NewLink();
LinkRef false_expr = cmp.NewLink();
// test op: positive / negative
if (!negate)
{
cmp.EmitTest(true_expr, false_expr);
}
else
{
cmp.EmitTest(false_expr, true_expr);
}
// test expression: lookahead / lookbehind
TestExpression.Compile(cmp, this.reverse);
cmp.EmitTrue();
// target expressions
if (TrueExpression == null) // (?= ...)
// Test :1, :2
// <test_expr>
// :2 False
// :1 <tail>
{
cmp.ResolveLink(false_expr);
cmp.EmitFalse();
cmp.ResolveLink(true_expr);
}
else
{
cmp.ResolveLink(true_expr);
TrueExpression.Compile(cmp, reverse);
if (FalseExpression == null) // (?(...) ...)
// Test :1, :2
// <test_expr>
// :1 <yes_expr>
// :2 <tail>
{
cmp.ResolveLink(false_expr);
}
else // (?(...) ... | ...)
// Test :1, :2
// <test_expr>
// :1 <yes_expr>
// Jump :3
// :2 <no_expr>
// :3 <tail>
{
LinkRef tail = cmp.NewLink();
cmp.EmitJump(tail);
cmp.ResolveLink(false_expr);
FalseExpression.Compile(cmp, reverse);
cmp.ResolveLink(tail);
}
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
IntervalCollection metaCollection = intervals.GetMetaCollection(GetIntervalCost);
int num = metaCollection.Count;
for (int i = 0; i < pos_cats.Length; i++)
{
if (pos_cats[i] || neg_cats[i])
{
num++;
}
}
if (num == 0)
{
return;
}
LinkRef linkRef = cmp.NewLink();
if (num > 1)
{
cmp.EmitIn(linkRef);
}
foreach (Interval item in metaCollection)
{
Interval interval = item;
if (interval.IsDiscontiguous)
{
BitArray bitArray = new BitArray(interval.Size);
foreach (Interval interval2 in intervals)
{
Interval i2 = interval2;
if (interval.Contains(i2))
{
for (int j = i2.low; j <= i2.high; j++)
{
bitArray[j - interval.low] = true;
}
}
}
cmp.EmitSet((char)interval.low, bitArray, negate, ignore, reverse);
}
else if (interval.IsSingleton)
{
cmp.EmitCharacter((char)interval.low, negate, ignore, reverse);
}
else
{
cmp.EmitRange((char)interval.low, (char)interval.high, negate, ignore, reverse);
}
}
for (int k = 0; k < pos_cats.Length; k++)
{
if (pos_cats[k])
{
if (neg_cats[k])
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)k, negate, reverse);
}
}
else if (neg_cats[k])
{
cmp.EmitNotCategory((Category)k, negate, reverse);
}
}
if (num > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(linkRef);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
// create the meta-collection
IntervalCollection meta =
intervals.GetMetaCollection(new IntervalCollection.CostDelegate(GetIntervalCost));
// count ops
int count = meta.Count;
for (int i = 0; i < pos_cats.Length; ++i)
{
if (pos_cats[i] || neg_cats [i])
{
++count;
}
}
if (count == 0)
{
return;
}
// emit in op for |meta| > 1
LinkRef tail = cmp.NewLink();
if (count > 1)
{
cmp.EmitIn(tail);
}
// emit character/range/sets from meta-collection
// we emit these first so that any 'ignore' flags will be noticed by the evaluator
foreach (Interval a in meta)
{
if (a.IsDiscontiguous) // Set
{
BitArray bits = new BitArray(a.Size);
foreach (Interval b in intervals)
{
if (a.Contains(b))
{
for (int i = b.low; i <= b.high; ++i)
{
bits[i - a.low] = true;
}
}
}
cmp.EmitSet((char)a.low, bits, negate, ignore, reverse);
}
else if (a.IsSingleton) // Character
{
cmp.EmitCharacter((char)a.low, negate, ignore, reverse);
}
else // Range
{
cmp.EmitRange((char)a.low, (char)a.high, negate, ignore, reverse);
}
}
// emit categories
for (int i = 0; i < pos_cats.Length; ++i)
{
if (pos_cats[i])
{
if (neg_cats [i])
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)i, negate, reverse);
}
}
else if (neg_cats[i])
{
cmp.EmitNotCategory((Category)i, negate, reverse);
}
}
// finish up
if (count > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(tail);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
// create the meta-collection
IntervalCollection meta =
intervals.GetMetaCollection(new IntervalCollection.CostDelegate(GetIntervalCost));
// count ops
int count = meta.Count;
for (int i = 0; i < pos_cats.Length; ++i)
{
// use BitArray.Get instead of indexer for speedups
//if (pos_cats[i]) ++ count;
//if (neg_cats[i]) ++ count;
if (pos_cats.Get(i))
{
++count;
}
if (neg_cats.Get(i))
{
++count;
}
}
if (count == 0)
{
return;
}
// emit in op for |meta| > 1
LinkRef tail = cmp.NewLink();
if (count > 1)
{
cmp.EmitIn(tail);
}
// emit categories
for (int i = 0; i < pos_cats.Length; ++i)
{
// use BitArray.Get instead of indexer for speedups
//if (pos_cats[i]) {
if (pos_cats.Get(i))
{
//if (neg_cats [i])
if (neg_cats.Get(i))
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)i, negate, reverse);
}
// } else if (neg_cats[i]) {
}
else if (neg_cats.Get(i))
{
cmp.EmitCategory((Category)i, !negate, reverse);
}
}
// emit character/range/sets from meta-collection
foreach (Interval a in meta)
{
if (a.IsDiscontiguous) // Set
{
BitArray bits = new BitArray(a.Size);
foreach (Interval b in intervals)
{
if (a.Contains(b))
{
for (int i = b.low; i <= b.high; ++i)
{
// use BitArray.Get instead of indexer for speedups : bits[i - a.low] = true;
bits.Set(i - a.low, true);
}
}
}
cmp.EmitSet((char)a.low, bits, negate, ignore, reverse);
}
else if (a.IsSingleton) // Character
{
cmp.EmitCharacter((char)a.low, negate, ignore, reverse);
}
else // Range
{
cmp.EmitRange((char)a.low, (char)a.high, negate, ignore, reverse);
}
}
// finish up
if (count > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(tail);
}
}
