// A Sym represents a single symbol table entry.
type Sym struct {
- Value uint64;
- Type byte;
- Name string;
- GoType uint64;
+ Value uint64;
+ Type byte;
+ Name string;
+ GoType uint64;
// If this symbol if a function symbol, the corresponding Func
- Func *Func;
+ Func *Func;
}
// Static returns whether this symbol is static (not visible outside its file).
if l == -1 || r == -1 || l == r {
return "";
}
- return s.Name[l+1:r];
+ return s.Name[l+1 : r];
}
// BaseName returns the symbol name without the package or receiver name.
func (s *Sym) BaseName() string {
if i := strings.LastIndex(s.Name, "."); i != -1 {
- return s.Name[i+1:len(s.Name)];
+ return s.Name[i+1 : len(s.Name)];
}
return s.Name;
}
// A Func collects information about a single function.
type Func struct {
- Entry uint64;
+ Entry uint64;
*Sym;
- End uint64;
- Params []*Sym;
- Locals []*Sym;
- FrameSize int;
- LineTable *LineTable;
- Obj *Obj;
+ End uint64;
+ Params []*Sym;
+ Locals []*Sym;
+ FrameSize int;
+ LineTable *LineTable;
+ Obj *Obj;
}
// An Obj represents a single object file.
type Obj struct {
- Funcs []Func;
- Paths []Sym;
+ Funcs []Func;
+ Paths []Sym;
}
/*
// symbols decoded from the program and provides methods to translate
// between symbols, names, and addresses.
type Table struct {
- Syms []Sym;
- Funcs []Func;
- Files map[string] *Obj;
- Objs []Obj;
-// textEnd uint64;
+ Syms []Sym;
+ Funcs []Func;
+ Files map[string]*Obj;
+ Objs []Obj;
+ // textEnd uint64;
}
type sym struct {
- value uint32;
- gotype uint32;
- typ byte;
- name []byte;
+ value uint32;
+ gotype uint32;
+ typ byte;
+ name []byte;
}
func walksymtab(data []byte, fn func(sym) os.Error) os.Error {
s.value = binary.BigEndian.Uint32(p[0:4]);
typ := p[4];
if typ&0x80 == 0 {
- return &DecodingError{len(data) - len(p) + 4, "bad symbol type", typ};
+ return &DecodingError{len(data)-len(p)+4, "bad symbol type", typ};
}
typ &^= 0x80;
s.typ = typ;
}
switch typ {
case 'z', 'Z':
- p = p[i+nnul:len(p)];
+ p = p[i+nnul : len(p)];
for i = 0; i+2 <= len(p); i += 2 {
if p[i] == 0 && p[i+1] == 0 {
nnul = 2;
}
s.name = p[0:i];
i += nnul;
- s.gotype = binary.BigEndian.Uint32(p[i:i+4]);
- p = p[i+4:len(p)];
+ s.gotype = binary.BigEndian.Uint32(p[i : i+4]);
+ p = p[i+4 : len(p)];
fn(s);
}
return nil;
// returning an in-memory representation.
func NewTable(symtab []byte, pcln *LineTable) (*Table, os.Error) {
var n int;
- err := walksymtab(symtab, func(s sym) os.Error { n++; return nil });
+ err := walksymtab(symtab, func(s sym) os.Error {
+ n++;
+ return nil;
+ });
if err != nil {
return nil, err;
}
lasttyp := uint8(0);
err = walksymtab(symtab, func(s sym) os.Error {
n := len(t.Syms);
- t.Syms = t.Syms[0:n+1];
+ t.Syms = t.Syms[0 : n+1];
ts := &t.Syms[n];
ts.Type = s.typ;
ts.Value = uint64(s.value);
nz++;
}
for i := 0; i < len(s.name); i += 2 {
- eltIdx := binary.BigEndian.Uint16(s.name[i:i+2]);
+ eltIdx := binary.BigEndian.Uint16(s.name[i : i+2]);
elt, ok := fname[eltIdx];
if !ok {
return &DecodingError{-1, "bad filename code", eltIdx};
fname[uint16(s.value)] = ts.Name;
}
lasttyp = s.typ;
- return nil
+ return nil;
});
if err != nil {
return nil, err;
t.Funcs = make([]Func, 0, nf);
t.Objs = make([]Obj, 0, nz);
- t.Files = make(map[string] *Obj);
+ t.Files = make(map[string]*Obj);
// Count text symbols and attach frame sizes, parameters, and
// locals to them. Also, find object file boundaries.
// Start new object
n := len(t.Objs);
- t.Objs = t.Objs[0:n+1];
+ t.Objs = t.Objs[0 : n+1];
obj = &t.Objs[n];
// Count & copy path symbols
// Fill in the function symbol
n := len(t.Funcs);
- t.Funcs = t.Funcs[0:n+1];
+ t.Funcs = t.Funcs[0 : n+1];
fn := &t.Funcs[n];
sym.Func = fn;
fn.Params = make([]*Sym, 0, np);
fn.FrameSize = int(s.Value);
case 'p':
n := len(fn.Params);
- fn.Params = fn.Params[0:n+1];
+ fn.Params = fn.Params[0 : n+1];
fn.Params[n] = s;
case 'a':
n := len(fn.Locals);
- fn.Locals = fn.Locals[0:n+1];
+ fn.Locals = fn.Locals[0 : n+1];
fn.Locals[n] = s;
}
}
case fn.Entry <= pc && pc < fn.End:
return fn;
default:
- funcs = funcs[m+1:len(funcs)];
+ funcs = funcs[m+1 : len(funcs)];
}
}
return nil;
// If there is no information, it returns fn == nil.
func (t *Table) PCToLine(pc uint64) (file string, line int, fn *Func) {
if fn = t.PCToFunc(pc); fn == nil {
- return
+ return;
}
file, line = fn.Obj.lineFromAline(fn.LineTable.PCToLine(pc));
return;
func (o *Obj) lineFromAline(aline int) (string, int) {
type stackEnt struct {
- path string;
- start int;
- offset int;
- prev *stackEnt;
- };
+ path string;
+ start int;
+ offset int;
+ prev *stackEnt;
+ }
noPath := &stackEnt{"", 0, 0, nil};
tos := noPath;
val := int(s.Value);
switch {
case depth == 1 && val >= line:
- return line - 1, nil;
+ return line-1, nil;
case s.Name == "":
depth--;
if depth == 0 {
break pathloop;
} else if depth == 1 {
- line += val - incstart;
+ line += val-incstart;
}
default:
// counter, either because the line is beyond the bounds of the file
// or because there is no code on the given line.
type UnknownLineError struct {
- File string;
- Line int;
+ File string;
+ Line int;
}
func (e *UnknownLineError) String() string {
// DecodingError represents an error during the decoding of
// the symbol table.
type DecodingError struct {
- off int;
- msg string;
- val interface{};
+ off int;
+ msg string;
+ val interface{};
}
func (e *DecodingError) String() string {
msg += fmt.Sprintf(" at byte %#x", e.off);
return msg;
}
-
// Errors returned during parsing and execution. Users may extract the information and reformat
// if they desire.
type Error struct {
- Line int;
- Msg string;
+ Line int;
+ Msg string;
}
func (e *Error) String() string {
- return fmt.Sprintf("line %d: %s", e.Line, e.Msg)
+ return fmt.Sprintf("line %d: %s", e.Line, e.Msg);
}
// Most of the literals are aces.
-var lbrace = []byte{ '{' }
-var rbrace = []byte{ '}' }
-var space = []byte{ ' ' }
-var tab = []byte{ '\t' }
+var lbrace = []byte{'{'}
+var rbrace = []byte{'}'}
+var space = []byte{' '}
+var tab = []byte{'\t'}
// The various types of "tokens", which are plain text or (usually) brace-delimited descriptors
const (
- tokAlternates = iota;
+ tokAlternates = iota;
tokComment;
tokEnd;
tokLiteral;
// FormatterMap is the type describing the mapping from formatter
// names to the functions that implement them.
-type FormatterMap map[string] func(io.Writer, interface{}, string)
+type FormatterMap map[string]func(io.Writer, interface{}, string)
// Built-in formatters.
-var builtins = FormatterMap {
- "html" : HtmlFormatter,
- "str" : StringFormatter,
- "" : StringFormatter,
+var builtins = FormatterMap{
+ "html": HtmlFormatter,
+ "str": StringFormatter,
+ "": StringFormatter,
}
// The parsed state of a template is a vector of xxxElement structs.
// Plain text.
type textElement struct {
- text []byte;
+ text []byte;
}
// A literal such as .meta-left or .meta-right
// A variable to be evaluated
type variableElement struct {
- linenum int;
- name string;
+ linenum int;
+ name string;
formatter string; // TODO(r): implement pipelines
}
// A .section block, possibly with a .or
type sectionElement struct {
- linenum int; // of .section itself
+ linenum int; // of .section itself
field string; // cursor field for this block
start int; // first element
or int; // first element of .or block
// A .repeated block, possibly with a .or and a .alternates
type repeatedElement struct {
- sectionElement; // It has the same structure...
+ sectionElement; // It has the same structure...
altstart int; // ... except for alternates
- altend int;
+ altend int;
}
// Template is the type that represents a template definition.
type Template struct {
fmap FormatterMap; // formatters for variables
// Used during parsing:
- ldelim, rdelim []byte; // delimiters; default {}
- buf []byte; // input text to process
- p int; // position in buf
- linenum int; // position in input
- error os.Error; // error during parsing (only)
+ ldelim, rdelim []byte; // delimiters; default {}
+ buf []byte; // input text to process
+ p int; // position in buf
+ linenum int; // position in input
+ error os.Error; // error during parsing (only)
// Parsed results:
elems *vector.Vector;
}
// the data item descends into the fields associated with sections, etc.
// Parent is used to walk upwards to find variables higher in the tree.
type state struct {
- parent *state; // parent in hierarchy
+ parent *state; // parent in hierarchy
data reflect.Value; // the driver data for this section etc.
wr io.Writer; // where to send output
errors chan os.Error; // for reporting errors during execute
}
func (parent *state) clone(data reflect.Value) *state {
- return &state{parent, data, parent.wr, parent.errors}
+ return &state{parent, data, parent.wr, parent.errors};
}
// New creates a new template with the specified formatter map (which
// Is c a white space character?
func white(c uint8) bool {
- return c == ' ' || c == '\t' || c == '\r' || c == '\n'
+ return c == ' ' || c == '\t' || c == '\r' || c == '\n';
}
// Safely, does s[n:n+len(t)] == t?
func equal(s []byte, n int, t []byte) bool {
b := s[n:len(s)];
if len(t) > len(b) { // not enough space left for a match.
- return false
+ return false;
}
- for i , c := range t {
+ for i, c := range t {
if c != b[i] {
- return false
+ return false;
}
}
- return true
+ return true;
}
// nextItem returns the next item from the input buffer. If the returned
sawLeft := false; // are we waiting for an opening delimiter?
special := false; // is this a {.foo} directive, which means trim white space?
// Delete surrounding white space if this {.foo} is the only thing on the line.
- trim_white := t.p == 0 || t.buf[t.p-1] == '\n';
+ trim_white := t.p == 0 || t.buf[t.p - 1] == '\n';
only_white := true; // we have seen only white space so far
var i int;
start := t.p;
break Loop;
case white(t.buf[i]):
// white space, do nothing
- case !sawLeft && equal(t.buf, i, t.ldelim): // sawLeft checked because delims may be equal
+ case !sawLeft && equal(t.buf, i, t.ldelim): // sawLeft checked because delims may be equal
// anything interesting already on the line?
if !only_white {
break Loop;
}
// is it a directive or comment?
- j := i + len(t.ldelim); // position after delimiter
+ j := i+len(t.ldelim); // position after delimiter
if j+1 < len(t.buf) && (t.buf[j] == '.' || t.buf[j] == '#') {
special = true;
if trim_white && only_white {
start = i;
}
- } else if i > t.p { // have some text accumulated so stop before delimiter
+ } else if i > t.p { // have some text accumulated so stop before delimiter
break Loop;
}
sawLeft = true;
- i = j - 1;
+ i = j-1;
case equal(t.buf, i, t.rdelim):
if !sawLeft {
t.parseError("unmatched closing delimiter");
if t.buf[i] == '\n' {
t.linenum++;
i++;
- break // stop after newline
+ break; // stop after newline
}
}
}
t.p = i;
- return item
+ return item;
}
// Turn a byte array into a white-space-split array of strings.
func words(buf []byte) []string {
s := make([]string, 0, 5);
- p := 0; // position in buf
+ p := 0; // position in buf
// one word per loop
for i := 0; ; i++ {
// skip white space
for ; p < len(buf) && !white(buf[p]); p++ {
}
if start == p { // no text left
- break
+ break;
}
if i == cap(s) {
ns := make([]string, 2*cap(s));
for j := range s {
- ns[j] = s[j]
+ ns[j] = s[j];
}
s = ns;
}
- s = s[0:i+1];
- s[i] = string(buf[start:p])
+ s = s[0 : i+1];
+ s[i] = string(buf[start:p]);
}
- return s
+ return s;
}
// Analyze an item and return its token type and, if it's an action item, an array of
// Comment
if item[len(t.ldelim)] == '#' {
tok = tokComment;
- return
+ return;
}
// Split into words
- w = words(item[len(t.ldelim): len(item)-len(t.rdelim)]); // drop final delimiter
+ w = words(item[len(t.ldelim) : len(item)-len(t.rdelim)]); // drop final delimiter
if len(w) == 0 {
t.parseError("empty directive");
return;
return;
}
t.parseError("bad directive: %s", item);
- return
+ return;
}
// -- Parsing
bar := strings.Index(name_formatter, "|");
if bar >= 0 {
name = name_formatter[0:bar];
- formatter = name_formatter[bar+1:len(name_formatter)];
+ formatter = name_formatter[bar+1 : len(name_formatter)];
}
// Probably ok, so let's build it.
v = &variableElement{t.linenum, name, formatter};
// Is it in user-supplied map?
if t.fmap != nil {
if _, ok := t.fmap[formatter]; ok {
- return
+ return;
}
}
// Is it in builtin map?
if _, ok := builtins[formatter]; ok {
- return
+ return;
}
t.parseError("unknown formatter: %s", formatter);
- return
+ return;
}
// Grab the next item. If it's simple, just append it to the template.
func (t *Template) parseSimple(item []byte) (done bool, tok int, w []string) {
tok, w = t.analyze(item);
if t.error != nil {
- return
+ return;
}
done = true; // assume for simplicity
switch tok {
t.elems.Push(t.newVariable(w[0]));
return;
}
- return false, tok, w
+ return false, tok, w;
}
// parseRepeated and parseSection are mutually recursive
if t.error != nil {
break;
}
- if len(item) == 0 {
+ if len(item) == 0 {
t.parseError("missing .end for .repeated section");
break;
}
break;
}
if done {
- continue
+ continue;
}
switch tok {
case tokEnd:
}
}
if t.error != nil {
- return nil
+ return nil;
}
if r.altend < 0 {
- r.altend = t.elems.Len()
+ r.altend = t.elems.Len();
}
r.end = t.elems.Len();
return r;
if t.error != nil {
break;
}
- if len(item) == 0 {
+ if len(item) == 0 {
t.parseError("missing .end for .section");
break;
}
break;
}
if done {
- continue
+ continue;
}
switch tok {
case tokEnd:
}
}
if t.error != nil {
- return nil
+ return nil;
}
s.end = t.elems.Len();
return s;
for t.error == nil {
item := t.nextItem();
if t.error != nil {
- break
+ break;
}
if len(item) == 0 {
- break
+ break;
}
done, tok, w := t.parseSimple(item);
if done {
- continue
+ continue;
}
switch tok {
case tokOr, tokEnd, tokAlternates:
// it represents the actual named field.
func (st *state) findVar(s string) reflect.Value {
if s == "@" {
- return st.data
+ return st.data;
}
data := st.data;
elems := strings.Split(s, ".", 0);
// Look up field; data must be a struct.
data = reflect.Indirect(data);
if data == nil {
- return nil
+ return nil;
}
typ, ok := data.Type().(*reflect.StructType);
if !ok {
- return nil
+ return nil;
}
field, ok := typ.FieldByName(elems[i]);
if !ok {
- return nil
+ return nil;
}
data = data.(*reflect.StructValue).FieldByIndex(field.Index);
}
- return data
+ return data;
}
// Is there no data to look at?
func empty(v reflect.Value) bool {
v = reflect.Indirect(v);
if v == nil {
- return true
+ return true;
}
switch v := v.(type) {
case *reflect.BoolValue:
field := st.findVar(name);
if field == nil {
if st.parent == nil {
- t.execError(st, t.linenum, "name not found: %s", name)
+ t.execError(st, t.linenum, "name not found: %s", name);
}
return t.varValue(name, st.parent);
}
fn(st.wr, val, formatter);
return;
}
- t.execError(st, v.linenum, "missing formatter %s for variable %s", formatter, v.name)
+ t.execError(st, v.linenum, "missing formatter %s for variable %s", formatter, v.name);
}
// Execute element i. Return next index to execute.
}
e := t.elems.At(i);
t.execError(st, 0, "internal error: bad directive in execute: %v %T\n", reflect.NewValue(e).Interface(), e);
- return 0
+ return 0;
}
// Execute the template.
func (t *Template) execute(start, end int, st *state) {
for i := start; i < end; {
- i = t.executeElement(i, st)
+ i = t.executeElement(i, st);
}
}
if !empty(field) {
// Execute the normal block.
if end < 0 {
- end = s.end
+ end = s.end;
}
} else {
// Execute the .or block. If it's missing, do nothing.
start, end = s.or, s.end;
if start < 0 {
- return
+ return;
}
}
for i := start; i < end; {
- i = t.executeElement(i, st)
+ i = t.executeElement(i, st);
}
}
ft := fv.Type().(*reflect.FuncType);
// TODO(rsc): NumIn() should return 0 here, because ft is from a curried FuncValue.
if mth.Name != "Iter" || ft.NumIn() != 1 || ft.NumOut() != 1 {
- continue
+ continue;
}
ct, ok := ft.Out(0).(*reflect.ChanType);
if !ok || ct.Dir() & reflect.RecvDir == 0 {
- continue
+ continue;
}
- return fv.Call(nil)[0].(*reflect.ChanValue)
+ return fv.Call(nil)[0].(*reflect.ChanValue);
}
- return nil
+ return nil;
}
// Execute a .repeated section
start, end := r.start, r.or;
if end < 0 {
- end = r.end
+ end = r.end;
}
if r.altstart >= 0 {
- end = r.altstart
+ end = r.altstart;
}
first := true;
// .alternates between elements
if !first && r.altstart >= 0 {
for i := r.altstart; i < r.altend; {
- i = t.executeElement(i, newst)
+ i = t.executeElement(i, newst);
}
}
first = false;
for i := start; i < end; {
- i = t.executeElement(i, newst)
+ i = t.executeElement(i, newst);
}
}
} else if ch := iter(field); ch != nil {
for {
e := ch.Recv();
if ch.Closed() {
- break
+ break;
}
newst := st.clone(e);
// .alternates between elements
if !first && r.altstart >= 0 {
for i := r.altstart; i < r.altend; {
- i = t.executeElement(i, newst)
+ i = t.executeElement(i, newst);
}
}
first = false;
for i := start; i < end; {
- i = t.executeElement(i, newst)
+ i = t.executeElement(i, newst);
}
}
} else {
t.execError(st, r.linenum, ".repeated: cannot repeat %s (type %s)",
- r.field, field.Type());
+ r.field, field.Type());
}
if first {
if start >= 0 {
newst := st.clone(field);
for i := start; i < end; {
- i = t.executeElement(i, newst)
+ i = t.executeElement(i, newst);
}
}
- return
+ return;
}
}
// A valid delimiter must contain no white space and be non-empty.
func validDelim(d []byte) bool {
if len(d) == 0 {
- return false
+ return false;
}
for _, c := range d {
if white(c) {
- return false
+ return false;
}
}
return true;
// the error.
func (t *Template) Parse(s string) os.Error {
if !validDelim(t.ldelim) || !validDelim(t.rdelim) {
- return &Error{1, fmt.Sprintf("bad delimiter strings %q %q", t.ldelim, t.rdelim)}
+ return &Error{1, fmt.Sprintf("bad delimiter strings %q %q", t.ldelim, t.rdelim)};
}
t.buf = strings.Bytes(s);
t.p = 0;
t = New(fmap);
err = t.Parse(s);
if err != nil {
- t = nil
+ t = nil;
}
- return
+ return;
}
// MustParse is like Parse but panics if the template cannot be parsed.
func MustParse(s string, fmap FormatterMap) *Template {
- t , err := Parse(s, fmap);
+ t, err := Parse(s, fmap);
if err != nil {
panic("template parse error: ", err.String());
}
- return t
+ return t;
}