diff options
Diffstat (limited to 'appl/spree/lib/cardlib.b')
| -rw-r--r-- | appl/spree/lib/cardlib.b | 917 |
1 files changed, 917 insertions, 0 deletions
diff --git a/appl/spree/lib/cardlib.b b/appl/spree/lib/cardlib.b new file mode 100644 index 00000000..67c4918b --- /dev/null +++ b/appl/spree/lib/cardlib.b @@ -0,0 +1,917 @@ +implement Cardlib; +include "sys.m"; + sys: Sys; +include "draw.m"; +include "sets.m"; + sets: Sets; + Set, set, A, B, All, None: import sets; +include "../spree.m"; + spree: Spree; + Attributes, Range, Object, Clique, Member, rand: import spree; +include "objstore.m"; + objstore: Objstore; +include "cardlib.m"; + +MAXPLAYERS: con 4; + +Layobject: adt { + lay: ref Object; + name: string; + packopts: int; + pick { + Obj => + obj: ref Object; # nil if it's a frame + Frame => + facing: int; # only valid if for frames + } +}; + +clique: ref Clique; +cmembers: array of ref Cmember; +cpids := array[8] of list of ref Cmember; + +# XXX first string is unnecessary as it's held in the Layobject anyway? +layouts := array[17] of list of (string, ref Layout, ref Layobject); +maxlayid := 1; +cmemberid := 1; + +archiveobjs: array of list of (string, ref Object); + +defaultrank := array[13] of {12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; +defaultsuitrank := array[] of {CLUBS => 0, DIAMONDS => 1, HEARTS => 2, SPADES => 3}; + +table := array[] of { + 0 => array[] of { + (-1, dTOP|EXPAND, dBOTTOM, dTOP), + }, + 1 => array [] of { + (0, dBOTTOM|FILLX, dBOTTOM, dTOP), + (-1, dTOP|EXPAND, dBOTTOM, dTOP), + }, + 2 => array[] of { + (0, dBOTTOM|FILLX, dBOTTOM, dTOP), + (1, dTOP|FILLX, dTOP, dBOTTOM), + (-1, dTOP|EXPAND, dBOTTOM, dTOP) + }, + 3 => array[] of { + (2, dRIGHT|FILLY, dRIGHT, dLEFT), + (0, dBOTTOM|FILLX, dBOTTOM, dTOP), + (1, dTOP|FILLX, dTOP, dBOTTOM), + (-1, dRIGHT|EXPAND, dBOTTOM, dTOP) + }, + 4 => array[] of { + (1, dLEFT|FILLY, dLEFT, dRIGHT), + (3, dRIGHT|FILLY, dRIGHT, dLEFT), + (0, dBOTTOM|FILLX, dBOTTOM, dTOP), + (2, dTOP|FILLX, dTOP, dBOTTOM), + (-1, dRIGHT|EXPAND, dBOTTOM, dTOP) + }, +}; + + +init(mod: Spree, g: ref Clique) +{ + sys = load Sys Sys->PATH; + sets = load Sets Sets->PATH; + if (sets == nil) + panic(sys->sprint("cannot load %s: %r", Sets->PATH)); + objstore = load Objstore Objstore->PATH; + if (objstore == nil) + panic(sys->sprint("cannot load %s: %r", Objstore->PATH)); + objstore->init(mod, g); + clique = g; + spree = mod; +} + +archive(): ref Object +{ + for (i := 0; i < len cmembers; i++) { + cp := cmembers[i]; + setarchivename(cp.obj, "member" + string i); + setarchivename(cp.layout.lay, "layout" + string i); + sel := cp.sel; + if (sel.stack != nil) + setarchivename(sel.stack, "sel" + string i); + } + for (i = 0; i < len layouts; i++) { + for (ll := layouts[i]; ll != nil; ll = tl ll) { + (name, lay, layobj) := hd ll; + if (name != nil) + layobj.lay.setattr("layname", name, None); + pick l := layobj { + Frame => + l.lay.setattr("facing", sides[l.facing], None); + Obj => + setarchivename(l.obj, "layid" + l.obj.getattr("layid")); + } + } + } + # XXX should archive layouts that aren't particular to a member. + archiveobj := clique.newobject(nil, None, "archive"); + setarchivename(archiveobj, "archive"); + archiveobj.setattr("maxlayid", string maxlayid, None); + archiveobj.setattr("cmemberid", string cmemberid, None); + return archiveobj; +} + +setarchivename(o: ref Object, name: string) +{ + objstore->setname(o, name); +} + +getarchiveobj(name: string): ref Object +{ + return objstore->get(name); +} + +archivearray(a: array of ref Object, name: string) +{ + for (i := 0; i < len a; i++) + objstore->setname(a[i], name + string i); +} + +getarchivearray(name: string): array of ref Object +{ + l: list of ref Object; + for (i := 0; ; i++) { + o := objstore->get(name + string i); + if (o == nil) + break; + l = o :: l; + } + a := array[i] of ref Object; + for (; l != nil; l = tl l) + a[--i] = hd l; + return a; +} + +unarchive(): ref Object +{ + objstore->unarchive(); + archiveobj := getarchiveobj("archive"); + cpl: list of ref Cmember; + for (i := 0; (o := getarchiveobj("member" + string i)) != nil; i++) { + cp := ref Cmember( + i, + int o.getattr("id"), + clique.membernamed(o.getattr("name")), + o, + ref Layout(getarchiveobj("layout" + string i)), + ref Selection(getarchiveobj("sel" + string i), -1, 1, (0, 0), nil) + ); + cp.sel.ownerid = cp.id; + sel := cp.sel; + if (sel.stack != nil && (selstr := sel.stack.getattr("sel")) != nil) { + (n, val) := sys->tokenize(selstr, " "); + if (tl val != nil && hd tl val == "-") + (sel.r.start, sel.r.end) = (int hd val, int hd tl tl val); + else { + idxl: list of int; + sel.isrange = 0; + for (; val != nil; val = tl val) + idxl = int hd val :: idxl; + sel.idxl = idxl; + } + } + lay := cp.layout.lay; + # there should be exactly one child, of type "layframe" + if (len lay.children != 1 || lay.children[0].objtype != "layframe") + panic("invalid layout"); + x := strhash(nil, len layouts); + layouts[x] = (nil, cp.layout, obj2layobj(lay.children[0])) :: layouts[x]; + unarchivelayoutobj(cp.layout, lay.children[0]); + cpl = cp :: cpl; + } + cmembers = array[len cpl] of ref Cmember; + for (; cpl != nil; cpl = tl cpl) { + cp := hd cpl; + cmembers[cp.ord] = cp; + idx := cp.id % len cpids; + cpids[idx] = cp :: cpids[idx]; + } + + maxlayid = int archiveobj.getattr("maxlayid"); + cmemberid = int archiveobj.getattr("cmemberid"); + return archiveobj; +} + +unarchivelayoutobj(layout: ref Layout, o: ref Object) +{ + for (i := 0; i < len o.children; i++) { + child := o.children[i]; + layobj := obj2layobj(child); + if (layobj.name != nil) { + x := strhash(layobj.name, len layouts); + layouts[x] = (layobj.name, layout, layobj) :: layouts[x]; + } + if (tagof(layobj) == tagof(Layobject.Frame)) + unarchivelayoutobj(layout, child); + } +} + +obj2layobj(o: ref Object): ref Layobject +{ + case o.objtype { + "layframe" => + return ref Layobject.Frame( + o, + o.getattr("layname"), + s2packopts(o.getattr("opts")), + searchopt(sides, o.getattr("facing")) + ); + "layobj" => + return ref Layobject.Obj( + o, + o.getattr("layname"), + s2packopts(o.getattr("opts")), + getarchiveobj("layid" + o.getattr("layid")) + ); + * => + panic("invalid layobject found, of type '" + o.objtype + "'"); + return nil; + } +} + +Cmember.join(member: ref Member, ord: int): ref Cmember +{ + cmembers = (array[len cmembers + 1] of ref Cmember)[0:] = cmembers; + if (ord == -1) + ord = len cmembers - 1; + else { + cmembers[ord + 1:] = cmembers[ord:len cmembers - 1]; + for (i := ord + 1; i < len cmembers; i++) + cmembers[i].ord = i; + } + cp := cmembers[ord] = ref Cmember(ord, cmemberid++, member, nil, nil, nil); + cp.obj = clique.newobject(nil, All, "member"); + cp.obj.setattr("id", string cp.id, All); + cp.obj.setattr("name", member.name, All); + cp.obj.setattr("you", string cp.id, None.add(member.id)); + cp.obj.setattr("cliquetitle", clique.fname, All); + cp.layout = newlayout(cp.obj, None.add(member.id)); + cp.sel = ref Selection(nil, cp.id, 1, (0, 0), nil); + + idx := cp.id % len cpids; + cpids[idx] = cp :: cpids[idx]; + return cp; +} + +Cmember.find(p: ref Member): ref Cmember +{ + id := p.id; + for (i := 0; i < len cmembers; i++) + if (cmembers[i].p.id == id) + return cmembers[i]; + return nil; +} + +Cmember.index(ord: int): ref Cmember +{ + if (ord < 0 || ord >= len cmembers) + return nil; + return cmembers[ord]; +} + +Cmember.next(cp: self ref Cmember, fwd: int): ref Cmember +{ + if (!fwd) + return cp.prev(1); + x := cp.ord + 1; + if (x >= len cmembers) + x = 0; + return cmembers[x]; +} + +Cmember.prev(cp: self ref Cmember, fwd: int): ref Cmember +{ + if (!fwd) + return cp.next(1); + x := cp.ord - 1; + if (x < 0) + x = len cmembers - 1; + return cmembers[x]; +} + +Cmember.leave(cp: self ref Cmember) +{ + ord := cp.ord; + cmembers[ord] = nil; + cmembers[ord:] = cmembers[ord + 1:]; + cmembers[len cmembers - 1] = nil; + cmembers = cmembers[0:len cmembers - 1]; + for (i := ord; i < len cmembers; i++) + cmembers[i].ord = i; + cp.obj.delete(); + dellayout(cp.layout); + cp.layout = nil; + idx := cp.id % len cpids; + l: list of ref Cmember; + ll := cpids[idx]; + for (; ll != nil; ll = tl ll) + if (hd ll != cp) + l = hd ll :: l; + cpids[idx] = l; + cp.ord = -1; +} + +Cmember.findid(id: int): ref Cmember +{ + for (l := cpids[id % len cpids]; l != nil; l = tl l) + if ((hd l).id == id) + return hd l; + return nil; +} + +newstack(parent: ref Object, owner: ref Member, spec: Stackspec): ref Object +{ + vis := All; + if (spec.conceal) { + vis = None; + if (owner != nil) + vis = vis.add(owner.id); + } + o := clique.newobject(parent, vis, "stack"); + o.setattr("maxcards", string spec.maxcards, All); + o.setattr("style", spec.style, All); + + # XXX provide some means for this to contain the member's name? + o.setattr("title", spec.title, All); + return o; +} + +makecard(deck: ref Object, c: Card, rear: string): ref Object +{ + card := clique.newobject(deck, None, "card"); + card.setattr("face", string c.face, All); + vis := None; + if(c.face) + vis = All; + card.setattr("number", string (c.number * 4 + c.suit), vis); + if (rear != nil) + card.setattr("rear", rear, All); + return card; +} + +makecards(deck: ref Object, r: Range, rear: string) +{ + for (i := r.start; i < r.end; i++) + for(suit := 0; suit < 4; suit++) + makecard(deck, (suit, i, 0), rear); +} + +# deal n cards to each member, if possible. +# deal in chunks for efficiency. +# if accuracy is required (e.g. dealing from an unshuffled +# deck containing known cards) then this'll have to change. +deal(deck: ref Object, n: int, stacks: array of ref Object, first: int) +{ + ncards := len deck.children; + ord := 0; + permember := n; + leftover := 0; + if (n * len stacks > ncards) { + # if trying to deal more cards than we've got, + # deal all that we've got, distributing the remainder fairly. + permember = ncards / len stacks; + leftover = ncards % len stacks; + } + for (i := 0; i < len stacks; i++) { + n = permember; + if (leftover > 0) { + n++; + leftover--; + } + priv := stacks[(first + i) % len stacks]; + deck.transfer((ncards - n, ncards), priv, len priv.children); + priv.setattr("n", string (int priv.getattr("n") + n), All); + # make cards visible to member + for (j := len priv.children - n; j < len priv.children; j++) + setface(priv.children[j], 1); + + ncards -= n; + } +} + +setface(card: ref Object, face: int) +{ + # XXX check parent stack style and if it's a pile, + # only expose a face up card at the top. + + card.setattr("face", string face, All); + if (face) + card.setattrvisibility("number", All); + else + card.setattrvisibility("number", None); +} + +nmembers(): int +{ + return len cmembers; +} + +getcard(card: ref Object): Card +{ + n := int card.getattr("number"); + (suit, num) := (n % 4, n / 4); + return Card(suit, num, int card.getattr("face")); +} + +getcards(stack: ref Object): array of Card +{ + a := array[len stack.children] of Card; + for (i := 0; i < len a; i++) + a[i] = getcard(stack.children[i]); + return a; +} + +discard(stk, pile: ref Object, facedown: int) +{ + n := len stk.children; + if (facedown) + for (i := 0; i < n; i++) + setface(stk.children[i], 0); + stk.transfer((0, n), pile, len pile.children); +} + +# shuffle children into a random order. first we make all the children +# invisible (which will cause them to be deleted in the clients) then +# shuffle to our heart's content, and make visible again... +shuffle(o: ref Object) +{ + ovis := o.visibility; + o.setvisibility(None); + a := o.children; + n := len a; + for (i := 0; i < n; i++) { + j := i + rand(n - i); + (a[i], a[j]) = (a[j], a[i]); + } + o.setvisibility(ovis); +} + +sort(o: ref Object, rank, suitrank: array of int) +{ + if (rank == nil) + rank = defaultrank; + if (suitrank == nil) + suitrank = defaultsuitrank; + ovis := o.visibility; + o.setvisibility(None); + cardmergesort(o.children, array[len o.children] of ref Object, rank, suitrank); + o.setvisibility(ovis); +} + +cardcmp(a, b: ref Object, rank, suitrank: array of int): int +{ + c1 := getcard(a); + c2 := getcard(b); + if (suitrank[c1.suit] != suitrank[c2.suit]) + return suitrank[c1.suit] - suitrank[c2.suit]; + return rank[c1.number] - rank[c2.number]; +} + +cardmergesort(a, b: array of ref Object, rank, suitrank: array of int) +{ + r := len a; + if (r > 1) { + m := (r-1)/2 + 1; + cardmergesort(a[0:m], b[0:m], rank, suitrank); + cardmergesort(a[m:], b[m:], rank, suitrank); + b[0:] = a; + for ((i, j, k) := (0, m, 0); i < m && j < r; k++) { + if (cardcmp(b[i], b[j], rank, suitrank) > 0) + a[k] = b[j++]; + else + a[k] = b[i++]; + } + if (i < m) + a[k:] = b[i:m]; + else if (j < r) + a[k:] = b[j:r]; + } +} + +# reverse and flip all cards in stack. +flip(stack: ref Object) +{ + ovis := stack.visibility; + stack.setvisibility(None); + a := stack.children; + (n, m) := (len a, len a / 2); + for (i := 0; i < m; i++) { + j := n - i - 1; + (a[i], a[j]) = (a[j], a[i]); + } + for (i = 0; i < n; i++) + setface(a[i], !int a[i].getattr("face")); + stack.setvisibility(ovis); +} + +selection(stack: ref Object): ref Selection +{ + if ((owner := stack.getattr("owner")) != nil && + (cp := Cmember.findid(int owner)) != nil) + return cp.sel; + return nil; +} + +Selection.set(sel: self ref Selection, stack: ref Object) +{ + if (stack == sel.stack) + return; + if (stack != nil) { + oldowner := stack.getattr("owner"); + if (oldowner != nil) { + oldcp := Cmember.findid(int oldowner); + if (oldcp != nil) + oldcp.sel.set(nil); + } + } + if (sel.stack != nil) + sel.stack.setattr("owner", nil, All); + sel.stack = stack; + sel.isrange = 1; + sel.r = (0, 0); + sel.idxl = nil; + setsel(sel); +} + +Selection.setexcl(sel: self ref Selection, stack: ref Object): int +{ + if (stack != nil && (oldowner := stack.getattr("owner")) != nil) + if ((cp := Cmember.findid(int oldowner)) != nil && !cp.sel.isempty()) + return 0; + sel.set(stack); + return 1; +} + +Selection.owner(sel: self ref Selection): ref Cmember +{ + return Cmember.findid(sel.ownerid); +} + +Selection.setrange(sel: self ref Selection, r: Range) +{ + if (!sel.isrange) { + sel.idxl = nil; + sel.isrange = 1; + } + sel.r = r; + setsel(sel); +} + +Selection.addindex(sel: self ref Selection, i: int) +{ + if (sel.isrange) { + sel.r = (0, 0); + sel.isrange = 0; + } + ll: list of int; + for (l := sel.idxl; l != nil; l = tl l) { + if (hd l >= i) + break; + ll = hd l :: ll; + } + if (l != nil && hd l == i) + return; + l = i :: l; + for (; ll != nil; ll = tl ll) + l = hd ll :: l; + sel.idxl = l; + setsel(sel); +} + +Selection.delindex(sel: self ref Selection, i: int) +{ + if (sel.isrange) { + sys->print("cardlib: delindex from range-type selection\n"); + return; + } + ll: list of int; + for (l := sel.idxl; l != nil; l = tl l) { + if (hd l == i) { + l = tl l; + break; + } + ll = hd l :: ll; + } + for (; ll != nil; ll = tl ll) + l = hd ll :: l; + sel.idxl = l; + setsel(sel); +} + +Selection.isempty(sel: self ref Selection): int +{ + if (sel.stack == nil) + return 1; + if (sel.isrange) + return sel.r.start == sel.r.end; + return sel.idxl == nil; +} + +Selection.isset(sel: self ref Selection, index: int): int +{ + if (sel.isrange) + return index >= sel.r.start && index < sel.r.end; + for (l := sel.idxl; l != nil; l = tl l) + if (hd l == index) + return 1; + return 0; +} + +Selection.transfer(sel: self ref Selection, dst: ref Object, index: int) +{ + if (sel.isempty()) + return; + src := sel.stack; + if (sel.isrange) { + r := sel.r; + sel.set(nil); + src.transfer(r, dst, index); + } else { + if (sel.stack == dst) { + sys->print("cardlib: cannot move multisel to same stack\n"); + return; + } + xl := l := sel.idxl; + sel.set(nil); + rl: list of Range; + for (; l != nil; l = tl l) { + r := Range(hd l, hd l); + last := l; + # concatenate adjacent items, for efficiency. + for (l = tl l; l != nil; (last, l) = (l, tl l)) { + if (hd l != r.end + 1) + break; + r.end = hd l; + } + rl = (r.start, r.end + 1) :: rl; + l = last; + } + # do ranges in reverse, so that later ranges + # aren't affected by earlier ones. + if (index == -1) + index = len dst.children; + for (; rl != nil; rl = tl rl) + src.transfer(hd rl, dst, index); + } +} + +setsel(sel: ref Selection) +{ + if (sel.stack == nil) + return; + s := ""; + if (sel.isrange) { + if (sel.r.end > sel.r.start) + s = string sel.r.start + " - " + string sel.r.end; + } else { + if (sel.idxl != nil) { + s = string hd sel.idxl; + for (l := tl sel.idxl; l != nil; l = tl l) + s += " " + string hd l; + } + } + if (s != nil) + sel.stack.setattr("owner", string sel.owner().id, All); + else + sel.stack.setattr("owner", nil, All); + vis := None.add(sel.owner().p.id); + sel.stack.setattr("sel", s, vis); + sel.stack.setattrvisibility("sel", vis); +} + +newlayout(parent: ref Object, vis: Set): ref Layout +{ + l := ref Layout(clique.newobject(parent, vis, "layout")); + x := strhash(nil, len layouts); + layobj := ref Layobject.Frame(nil, "", dTOP|EXPAND|FILLX|FILLY, dTOP); + layobj.lay = clique.newobject(l.lay, All, "layframe"); + layobj.lay.setattr("opts", packopts2s(layobj.packopts), All); + layouts[x] = (nil, l, layobj) :: layouts[x]; +# sys->print("[%d] => ('%s', %ux, %ux) (new layout)\n", x, "", l, layobj); + return l; +} + +addlayframe(name, parent: string, layout: ref Layout, packopts: int, facing: int) +{ +# sys->print("addlayframe('%s', %ux, name: %s\n", parent, layout, name); + addlay(parent, layout, ref Layobject.Frame(nil, name, packopts, facing)); +} + +addlayobj(name, parent: string, layout: ref Layout, packopts: int, obj: ref Object) +{ +# sys->print("addlayobj('%s', %ux, name: %s, obj %d\n", parent, layout, name, obj.id); + addlay(parent, layout, ref Layobject.Obj(nil, name, packopts, obj)); +} + +addlay(parent: string, layout: ref Layout, layobj: ref Layobject) +{ + a := layouts; + name := layobj.name; + x := strhash(name, len a); + added := 0; + for (nl := a[strhash(parent, len a)]; nl != nil; nl = tl nl) { + (s, lay, parentlay) := hd nl; + if (s == parent && (layout == nil || layout == lay)) { + pick p := parentlay { + Obj => + sys->fprint(sys->fildes(2), + "cardlib: cannot add layout to non-frame: %d\n", p.obj.id); + Frame => + nlayobj := copylayobj(layobj); + nlayobj.packopts = packoptsfacing(nlayobj.packopts, p.facing); + o: ref Object; + pick lo := nlayobj { + Obj => + o = clique.newobject(p.lay, All, "layobj"); + id := lo.obj.getattr("layid"); + if (id == nil) { + id = string maxlayid++; + lo.obj.setattr("layid", id, All); + } + o.setattr("layid", id, All); + Frame => + o = clique.newobject(p.lay, All, "layframe"); + lo.facing = (lo.facing + p.facing) % 4; + } + o.setattr("opts", packopts2s(nlayobj.packopts), All); + nlayobj.lay = o; + if (name != nil) + a[x] = (name, lay, nlayobj) :: a[x]; + added++; + } + } + } + if (added == 0) + sys->print("no parent found, adding '%s', parent '%s', layout %ux\n", + layobj.name, parent, layout); +# sys->print("%d new entries\n", added); +} + +maketable(parent: string) +{ + # make a table for all current members. + plcount := len cmembers; + packopts := table[plcount]; + for (i := 0; i < plcount; i++) { + layout := cmembers[i].layout; + for (j := 0; j < len packopts; j++) { + (ord, outer, inner, facing) := packopts[j]; + name := "public"; + if (ord != -1) + name = "p" + string ((ord + i) % plcount); + addlayframe("@" + name, parent, layout, outer, dTOP); + addlayframe(name, "@" + name, layout, inner, facing); + } + } +} + +dellay(name: string, layout: ref Layout) +{ + a := layouts; + x := strhash(name, len a); + rl: list of (string, ref Layout, ref Layobject); + for (nl := a[x]; nl != nil; nl = tl nl) { + (s, lay, layobj) := hd nl; + if (s != name || (layout != nil && layout != lay)) + rl = hd nl :: rl; + } + a[x] = rl; +} + +dellayout(layout: ref Layout) +{ + for (i := 0; i < len layouts; i++) { + ll: list of (string, ref Layout, ref Layobject); + for (nl := layouts[i]; nl != nil; nl = tl nl) { + (s, lay, layobj) := hd nl; + if (lay != layout) + ll = hd nl :: ll; + } + layouts[i] = ll; + } +} + +copylayobj(obj: ref Layobject): ref Layobject +{ + pick o := obj { + Frame => + return ref *o; + Obj => + return ref *o; + } + return nil; +} + +packoptsfacing(opts, facing: int): int +{ + if (facing == dTOP) + return opts; + nopts := 0; + + # 4 directions + nopts |= (facing + (opts & dMASK)) % 4; + + # 2 orientations + nopts |= ((facing + ((opts & oMASK) >> oSHIFT)) % 4) << oSHIFT; + + # 8 anchorpoints (+ centre) + a := (opts & aMASK); + if (a != aCENTRE) + a = ((((a >> aSHIFT) - 1 + facing * 2) % 8) + 1) << aSHIFT; + nopts |= a; + + # two fill options + if (facing % 2) { + if (opts & FILLX) + nopts |= FILLY; + if (opts & FILLY) + nopts |= FILLX; + } else + nopts |= (opts & (FILLX | FILLY)); + + nopts |= (opts & EXPAND); + return nopts; +} + +# these arrays are dependent on the ordering of +# the relevant constants defined in cardlib.m + +sides := array[] of {"top", "left", "bottom", "right"}; +anchors := array[] of {"centre", "n", "nw", "w", "sw", "s", "se", "e", "ne"}; +orientations := array[] of {"right", "up", "left", "down"}; +fills := array[] of {"none", "x", "y", "both"}; + +packopts2s(opts: int): string +{ + s := orientations[(opts & oMASK) >> oSHIFT] + + " -side " + sides[opts & dMASK]; + if ((opts & aMASK) != aCENTRE) + s += " -anchor " + anchors[(opts & aMASK) >> aSHIFT]; + if (opts & EXPAND) + s += " -expand 1"; + if (opts & (FILLX | FILLY)) + s += " -fill " + fills[(opts & FILLMASK) >> FILLSHIFT]; + return s; +} + +searchopt(a: array of string, s: string): int +{ + for (i := 0; i < len a; i++) + if (a[i] == s) + return i; + panic("unknown pack option '" + s + "'"); + return 0; +} + +s2packopts(s: string): int +{ + (nil, toks) := sys->tokenize(s, " "); + if (toks == nil) + panic("invalid packopts: " + s); + p := searchopt(orientations, hd toks) << oSHIFT; + for (toks = tl toks; toks != nil; toks = tl tl toks) { + if (tl toks == nil) + panic("invalid packopts: " + s); + arg := hd tl toks; + case hd toks { + "-anchor" => + p |= searchopt(anchors, arg) << aSHIFT; + "-fill" => + p |= searchopt(fills, arg) << FILLSHIFT; + "-side" => + p |= searchopt(sides, arg) << dSHIFT; + "-expand" => + if (int hd tl toks) + p |= EXPAND; + * => + panic("unknown pack option: " + hd toks); + } + } + return p; +} + +panic(e: string) +{ + sys->fprint(sys->fildes(2), "cardlib panic: %s\n", e); + raise "panic"; +} + +assert(b: int, err: string) +{ + if (b == 0) + raise "parse:" + err; +} + +# from Aho Hopcroft Ullman +strhash(s: string, n: int): int +{ + h := 0; + m := len s; + for(i := 0; i<m; i++){ + h = 65599 * h + s[i]; + } + return (h & 16r7fffffff) % n; +} |