コード例 #1
0
ファイル: typedef.go プロジェクト: jerchung/completion
func check(i interface{}, name content.FullyQualifiedName) error {
	if err := content.Validate(i); err != nil {
		return err
	}
	if name.Relative[0] == '<' || name.Relative[0] == '$' {
		return errors.New(fmt.Sprintf("Not .net referenceable name: %s", name))
	}
	return nil
}
コード例 #2
0
func TestLoadAllAssemblies(t *testing.T) {
	paths := DefaultPaths()
	if len(paths) == 0 {
		t.Skip("Neither mono nor Windows .NET Framework paths were possible to get")
	}
	var (
		inChan  = make(chan string, 64)
		outChan = make(chan error, 32)
		wg      sync.WaitGroup
		once    sync.Once
	)
	worker := func() {
		wg.Add(1)

		for fn := range inChan {
			start := time.Now()
			data, err := ioutil.ReadFile(fn)
			if err != nil {
				outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
				continue
			}
			if asm, err := LoadAssembly(bytes.NewReader(data)); err != nil {
				if err != ErrNotAssembly && err != ErrMetadata {
					outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
				} else {
					t.Logf("%s is not a .net assembly", fn)
				}
			} else {
				ci := ConcreteTableIndex{metadataUtil: &asm.MetadataUtil, table: id_TypeDef, index: 1}
				for i := uint32(0); i < asm.Tables[id_TypeDef].Rows; i++ {
					ci.index = i + 1
					if td, err := TypeDefFromIndex(&ci); err != nil {
						outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
					} else {
						if n := td.Name(); content.Validate(&n) != nil {
							continue
						} else if _, err := td.ToContentType(); err != nil {
							outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
						}
					}
				}
				ci.table = id_Module
				ci.index = 1
				if d, err := ci.Data(); err != nil {
					outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
				} else {
					mr := d.(*ModuleRow)
					ci.table = id_Assembly
					if d2, err := ci.Data(); err != nil {
						if asm.Tables[id_Assembly].Rows == 0 {
							// It's ok for an assembly to not have an assembly table, although
							// I've only ever seen this with System.EnterpriseServices.Wrapper.dll
							t.Logf("Successfully loaded module %50s {%s}", mr.Name, mr.Mvid)
						} else {
							outChan <- errors.New(fmt.Sprintf("%s: %s\n", fn, err))
						}
					} else {
						ar := d2.(*AssemblyRow)
						if mn, an := string(mr.Name), string(ar.Name); !strings.HasPrefix(mn, an) && (an != "mscorlib" && mn != "CommonLanguageRuntimeLibrary") {
							outChan <- errors.New(fmt.Sprintf("The assembly name isn't the prefix of the module name: %s, %s", an, mn))
						} else {
							t.Logf("Successfully loaded module %50s {%s} %s (%s)", mn, mr.Mvid, an, time.Now().Sub(start))
						}
					}
				}
			}
		}
		wg.Done()
		wg.Wait()
		once.Do(func() {
			close(outChan)
		})
	}
	for i := 0; i < runtime.NumCPU(); i++ {
		go worker()
	}

	for _, path := range paths {
		if f, err := os.Open(path); err != nil {
			t.Error(err)
		} else {
			fi, err := f.Readdir(0)
			if err != nil {
				t.Fatal(err)
			}

			for i := 0; i < len(fi); {
				if fn := fi[i].Name(); strings.HasSuffix(fn, ".dll") {
					if len(inChan)+1 >= cap(inChan) {
						for len(outChan) > 0 {
							o := <-outChan
							if o != nil {
								t.Error(o)
							}
						}
						time.Sleep(time.Microsecond * 100)
					} else {
						inChan <- path + fn
						i++
					}
				} else {
					i++
				}
			}
		}
	}
	close(inChan)
	for o := range outChan {
		if o != nil {
			t.Error(o)
		}
	}
}
コード例 #3
0
ファイル: typedef.go プロジェクト: jerchung/completion
func (td *TypeDef) ToContentType() (t *content.Type, err error) {
	if td.ct.Name.Relative != "" {
		return &td.ct, nil
	}
	t = &content.Type{}
	t.Name = td.Name()
	t.Flags = td.row.Flags.Convert()

	if ext, err := td.Extends(); err != nil && err != ErrInterface {
		return nil, err
	} else {
		t.Extends = ext
	}
	if imp, err := td.Implements(); err != nil {
		return nil, err
	} else {
		t.Implements = imp
	}
	if f, err := td.Fields(); err != nil {
		return nil, err
	} else {
		t.Fields = f
	}
	if f, err := td.Methods(); err != nil {
		return nil, err
	} else {
		t.Methods = f
	}

	idx := td.mu.Search(id_NestedClass, func(ti TableIndex) bool {
		if raw, err := ti.Data(); err == nil {
			c := raw.(*NestedClassRow)
			return c.NestedClass.Index() > td.index.Index()
		}
		return false
	})
	if idx != nil {
		ci := idx.(*ConcreteTableIndex)
		table := td.mu.Tables[idx.Table()]
		for i := idx.Index(); i < table.Rows+1; i++ {
			ci.index = i
			if raw, err := ci.Data(); err != nil {
				return nil, err
			} else {
				row := raw.(*NestedClassRow)
				if row.EnclosingClass.Index() != td.index.Index() {
					break
				} else if td2, err := TypeDefFromIndex(row.NestedClass); err != nil {
					return nil, err
				} else {
					ct := content.Type{}
					ct.Name = td2.Name()
					ct.Flags = td2.row.Flags.Convert()
					if err := check(&ct, ct.Name); err != nil {
						log4go.Fine("Skipping nested type: %s, %+v, %+v", err, ct, td2.row)
						continue
					}

					t.Types = append(t.Types, ct)
				}
			}
		}
	}
	err = content.Validate(&t)
	td.ct = *t
	return
}