text:
SUMMARY = "Integrate Bluetooth within KDE workspace and applications"
LICENSE = "GPLv2+"
LIC_FILES_CHKSUM = " \
    file://HACKING;md5=ea929f30c0ac1f4fe1a778821aecc4cd \
"

inherit kde-plasma gettext

DEPENDS += " \
    kauth-native \
    kcoreaddons \
    kcoreaddons-native \
    kwidgetsaddons \
    kdbusaddons \
    knotifications \
    kwindowsystem \
    kiconthemes \
    kpackage-native \
    plasma-framework \
    ki18n \
    kio \
    bluez-qt \
    kded \
    shared-mime-info-native \
"

PV = "${PLASMA_VERSION}"
SRC_URI[md5sum] = "ff9d89776b90c96911ea2dcce203b06f"
SRC_URI[sha256sum] = "afcbd59b2f5f92b7404c2c474ab154a4f12705e3312f274367cc49b31802a72a"

FILES_${PN} += " \
    ${datadir}/bluedevilwizard \
    ${datadir}/mime \
    ${datadir}/k*5 \
    ${datadir}/plasma \
    ${datadir}/remoteview \
    ${OE_QMAKE_PATH_PLUGINS} \
    ${OE_QMAKE_PATH_QML}/org/kde/plasma/private/bluetooth \
"

FILES_${PN}-dbg += " \
    ${OE_QMAKE_PATH_PLUGINS}/.debug \
    ${OE_QMAKE_PATH_PLUGINS}/*/.debug \
    ${OE_QMAKE_PATH_PLUGINS}/*/*/.debug \
    ${OE_QMAKE_PATH_QML}/org/kde/plasma/private/bluetooth/.debug \
"


text:
require flask-restful.inc

PR = "${INC_PR}.0"

DEPENDS += "python-setuptools-native"
RDEPENDS_${PN} += "python-aniso8601 python-flask python-six python-tz"

license: MIT

repository: meta-debian/meta-debian-extra

license_type: permissive

repo_name: meta-debian/meta-debian-extra

branch_name: refs/heads/morty

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
@article{roest_fear_2017,
 author = {Roest, A.M. and de Jonge, P. and Lim, C.C.W. and Stein, D.J. and Al-Hamzawi, A. and Alonso, J. and Benjet, C. and Bruffaerts, R. and Bunting, B. and Caldas-de-Almeida, J.M. and Ciutan, M. and de Girolamo, G. and Hu, C. and Levinson, D. and Nakamura, Y. and Navarro-Mateu, F. and Piazza, M. and Posada-Villa, J. and Torres, Y. and Wojtyniak, B. and Kessler, R.C. and Scott, K.M.},
 doi = {10.1016/j.jpsychores.2017.03.015},
 issn = {00223999},
 journal = {Journal of Psychosomatic Research},
 language = {en},
 month = {May},
 pages = {67--75},
 shorttitle = {Fear and distress disorders as predictors of heart disease},
 title = {Fear and distress disorders as predictors of heart disease: A temporal perspective},
 url = {https://linkinghub.elsevier.com/retrieve/pii/S0022399916305207},
 urldate = {2021-03-27},
 volume = {96},
 year = {2017}
}

branch_name: refs/heads/master

extension: bib


text:
package main

import (
	"bytes"
	"debug/elf"
	"encoding/binary"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"sort"
	"strconv"
	"strings"

	"github.com/qeedquan/go-binutils/iberty/demangle"
	"golang.org/x/arch/x86/x86asm"
)

func main() {
	log.SetFlags(0)
	log.SetPrefix("xeas: ")

	xs := NewXS()
	flag.IntVar(&xs.Mode, "m", xs.Mode, "processor mode")
	flag.Usage = usage
	flag.Parse()
	if flag.NArg() < 1 {
		usage()
	}

	ck(xs.Open(flag.Arg(0)))
	fn := xs.NewFunc("", flag.Arg(1), flag.Arg(2))
	cg := xs.BuildCallGraph(fn)
	xs.DumpCallGraph(cg)
}

func usage() {
	fmt.Fprintln(os.Stderr, "usage: xeas [options] file start end")
	flag.PrintDefaults()
	os.Exit(2)
}

func ck(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

const (
	ANONE = iota
	AREG
	AREL
	AMEM
)

type XS struct {
	f      *elf.File
	Mem    []*Mem
	Sym    []*Symbol
	Dynsym []*Symbol
	Mode   int
}

type Mem struct {
	Name  string
	Start uint64
	End   uint64
	Data  []byte
}

type BasicBlock struct {
	Entry uint64
	Exit  uint64
}

type Func struct {
	Name    string
	Start   uint64
	End     uint64
	Dynamic bool
	Inst    []*Inst
	BB      []*BasicBlock
	Callee  []*Func
	Label   []*Symbol
}

type Inst struct {
	x86asm.Inst
	Enc   []byte
	Start uint64
	End   uint64
	Err   error
}

type Symbol struct {
	elf.Symbol
	Dynamic bool
	Label   bool
}

func NewXS() *XS {
	return &XS{
		Mode: 64,
	}
}

func (xs *XS) Open(name string) error {
	var err error

	xs.f, err = elf.Open(name)
	if err != nil {
		return err
	}

	sym, _ := xs.f.Symbols()
	sort.SliceStable(sym, func(i, j int) bool {
		return sym[i].Value < sym[j].Value
	})
	xs.Sym = xs.Sym[:0]
	for i := range sym {
		xs.Sym = append(xs.Sym, &Symbol{
			Symbol:  sym[i],
			Dynamic: false,
		})
	}

	for _, p := range xs.f.Progs {
		if p.Type != elf.PT_LOAD {
			continue
		}
		m := xs.Mmap(name, p.Vaddr, p.Memsz)
		Data, err := ioutil.ReadAll(p.Open())
		if err != nil {
			return fmt.Errorf("failed to load segment: %v", err)
		}
		copy(m.Data, Data)
	}
	if len(xs.Mem) == 0 {
		return fmt.Errorf("executable has no loadable segment")
	}

	dynsym, _ := xs.f.DynamicSymbols()
	for _, p := range xs.f.Sections {
		if p.Type != elf.SHT_RELA {
			continue
		}
		q := xs.f.Section(strings.TrimPrefix(p.Name, ".rela"))
		if q == nil {
			continue
		}

		data, err := p.Data()
		if err != nil {
			return fmt.Errorf("failed to get relative section: %v", err)
		}

		rd := bytes.NewReader(data)
		for {
			var (
				rel uint64
				idx uint64
			)
			switch xs.f.Class {
			case elf.ELFCLASS64:
				var v elf.Rela64
				err = binary.Read(rd, xs.f.ByteOrder, &v)
				rel = v.Info & 0xffffffff
				idx = v.Info >> 32
			case elf.ELFCLASS32:
				var v elf.Rela32
				err = binary.Read(rd, xs.f.ByteOrder, &v)
				rel = uint64(v.Info & 0xffff)
				idx = uint64(v.Info >> 16)
			}
			if err == io.EOF {
				break
			}
			if err != nil {
				return err
			}

			if idx >= uint64(len(dynsym)) {
				continue
			}

			switch {
			case rel == uint64(elf.R_X86_64_JMP_SLOT),
				rel == uint64(elf.R_386_JMP_SLOT):
				ds := &dynsym[idx-1]
				ds.Value = q.Addr + q.Entsize*idx
				ds.Size = q.Entsize
			}
		}
	}
	for i := range dynsym {
		xs.Dynsym = append(xs.Dynsym, &Symbol{
			Symbol:  dynsym[i],
			Dynamic: true,
		})
	}

	return nil
}

func (xs *XS) Mmap(name string, addr, size uint64) *Mem {
	m := &Mem{
		Name:  name,
		Start: addr,
		End:   addr + size,
		Data:  make([]byte, size),
	}
	for _, mp := range xs.Mem {
		if mp.Start <= m.Start && m.Start <= mp.End ||
			mp.Start <= m.End && m.End <= mp.End {
			log.Fatalf("mmap: overlapping Memory: %q %x-%x %x-%x\n",
				name, m.Start, m.End, mp.Start, mp.End)
		}
	}
	xs.Mem = append(xs.Mem, m)
	sort.Slice(xs.Mem, func(i, j int) bool {
		return xs.Mem[i].Start < xs.Mem[j].Start
	})
	return m
}

func (xs *XS) symAt(addr uint64) (y *Symbol, n int) {
	n = -1
	for i, s := range xs.Sym {
		if s.Value <= addr {
			y = xs.Sym[i]
			n = i
		}
	}
	return
}

func (xs *XS) NewFunc(name, sp, ep string) *Func {
	var start, end uint64
	start, sdx := xs.ftoi(sp, xs.f.Entry)
	if sdx >= 0 {
		if xs.Sym[sdx].Size != 0 {
			end = start + xs.Sym[sdx].Size
		} else if sdx+1 < len(xs.Sym) {
			end = xs.Sym[sdx+1].Value
		}
	} else {
		if _, i := xs.symAt(start); i+1 < len(xs.Sym) {
			end = xs.Sym[i+1].Value
		} else {
			end = xs.Mem[len(xs.Mem)-1].End
		}
	}

	if ep != "" {
		end, _ = xs.ftoi(ep, end)
	}

	if name == "" {
		if isAlpha(sp) {
			name = sp
		} else {
			if s, _ := xs.symAt(start); s != nil {
				name = s.Name
			} else {
				name = fmt.Sprintf("func_%x", start)
			}
		}
	}

	dynamic := false
	sym, _ := xs.lookupAddr(start)
	if sym != nil {
		if sym.Dynamic {
			dynamic = true
		}
	}

	inst := xs.fetchv(start, end)
	bb := xs.genBB(inst)
	callee := xs.genCalls(start, inst)
	label := xs.genLabel(inst)
	return &Func{
		Name:    name,
		Start:   start,
		End:     end,
		Inst:    inst,
		BB:      bb,
		Callee:  callee,
		Label:   label,
		Dynamic: dynamic,
	}
}

func (xs *XS) ftoi(str string, def uint64) (uint64, int) {
	if str == "" {
		return def, -1
	}

	n, err := strconv.ParseUint(str, 0, 64)
	if err == nil {
		return n, -1
	}

	for i, s := range xs.Sym {
		if s.Name == str {
			return s.Value, i
		}
	}

	log.Fatalf("unable to find symbol %q", str)
	panic("unreachable")
}

func (xs *XS) Data(addr, size uint64) []byte {
	b := make([]byte, size)
	n := uint64(0)
	for _, m := range xs.Mem {
		if m.Start <= addr && addr <= m.End {
			i := addr - m.Start
			j := i + size - n
			if k := uint64(len(m.Data)); j > k {
				j = k
			}
			n += uint64(copy(b, m.Data[i:j]))
		}
	}

	if n == 0 {
		return nil
	}
	return b[:n]
}

func (xs *XS) fetch(ip uint64) (*Inst, error) {
	code := xs.Data(ip, 16)
	if code == nil {
		return nil, fmt.Errorf("failed to fetch instruction at unmapped memory %#x", ip)
	}
	if len(code) == 0 {
		return nil, io.EOF
	}

	i, err := x86asm.Decode(code, xs.Mode)
	return &Inst{
		Inst:  i,
		Start: ip,
		End:   ip + uint64(i.Len),
		Enc:   code[:i.Len],
	}, err
}

func (xs *XS) fetchv(start, end uint64) []*Inst {
	insts := make([]*Inst, 0, 256)
	ip := start
	for ip < end {
		inst, err := xs.fetch(ip)
		if err != nil {
			insts = append(insts, &Inst{
				Err: err,
			})
			break
		}
		insts = append(insts, inst)
		ip += uint64(inst.Len)
	}

	return insts
}

func (xs *XS) genBB(inst []*Inst) []*BasicBlock {
	var bb []*BasicBlock

	i := 0
	for j, inst := range inst {
		if isBranch(inst) {
			bb = append(bb, &BasicBlock{uint64(i), uint64(j)})
			i = j + 1
		}
	}
	return bb
}

func (xs *XS) genLabel(inst []*Inst) []*Symbol {
	if len(inst) == 0 {
		return nil
	}

	var label []*Symbol
	start := inst[0].Start
	end := inst[len(inst)-1].End
loop:
	for _, inst := range inst {
		if !isBranch(inst) && !isRel(inst) {
			continue
		}

		addr := getRel(inst)
		if start <= addr && addr < end {
			for i := range label {
				if label[i].Value == addr {
					continue loop
				}
			}
			label = append(label, &Symbol{
				Symbol: elf.Symbol{
					Value: addr,
				},
			})
		}
	}
	sort.SliceStable(label, func(i, j int) bool {
		return label[i].Value < label[j].Value
	})

	return label
}

func (xs *XS) genCalls(start uint64, inst []*Inst) []*Func {
	var fn []*Func
	addr := start
	for _, inst := range inst {
		if inst.Op != x86asm.CALL {
			addr += uint64(inst.Len)
			continue
		}

		switch a := inst.Args[0].(type) {
		case x86asm.Rel:
			ip := addr + uint64(inst.Len) + uint64(a)
			sym, _ := xs.lookupAddr(ip)
			if sym == nil {
				sym = &Symbol{
					Symbol: elf.Symbol{
						Name:  fmt.Sprintf("func%x", ip),
						Value: ip,
						Size:  32,
					},
				}
			}
			fn = append(fn, &Func{
				Name:    sym.Name,
				Start:   sym.Value,
				End:     sym.Value + sym.Size,
				Dynamic: sym.Dynamic,
			})
		}

		addr += uint64(inst.Len)
	}
	return fn
}

func (xs *XS) lookupAddr(addr uint64) (*Symbol, int) {
	for _, p := range [][]*Symbol{xs.Sym, xs.Dynsym} {
		for i, s := range p {
			if s.Value <= addr && addr < s.Value+s.Size {
				return s, i
			}
		}
	}
	return nil, -1
}

func (xs *XS) BuildCallGraph(root *Func) map[string]*Func {
	cg := make(map[string]*Func)
	fl := []*Func{root}
	for ; len(fl) > 0; fl = fl[1:] {
		fn := fl[0]
		if _, found := cg[fn.Name]; found {
			continue
		}

		cg[fn.Name] = fn
		for _, c := range fn.Callee {
			fl = append(fl, xs.NewFunc(c.Name, fmt.Sprint(c.Start), fmt.Sprint(c.End)))
		}
	}
	return cg
}

func (xs *XS) DumpCallGraph(cg map[string]*Func) {
	var fn []*Func
	for _, f := range cg {
		fn = append(fn, f)
	}
	sort.SliceStable(fn, func(i, j int) bool {
		if fn[i].Dynamic && !fn[j].Dynamic {
			return true
		}
		if fn[j].Dynamic && !fn[i].Dynamic {
			return false
		}
		return fn[i].Name < fn[j].Name
	})

	w := os.Stdout
	for _, f := range fn {
		if !f.Dynamic {
			fmt.Fprintf(w, ".globl %s\n", f.Name)
		}
	}
	fmt.Fprintf(w, "\n")
	for _, f := range fn {
		addr := f.Start

		cname := demangle.Cplus(f.Name, demangle.PARAMS|demangle.TYPES|demangle.VERBOSE)
		if cname == "" {
			cname = f.Name
		}
		fmt.Fprintf(w, "# %s %#x:%#x\n", cname, f.Start, f.End)
		if f.Dynamic {
			fmt.Fprintf(w, "# dynamic function\n")
		}
		fmt.Fprintf(w, "%s:\n", f.Name)
		if f.Dynamic {
			fmt.Fprintf(w, "\t%-64s # %#x\n\n", "retq", addr)
			continue
		}

		l := 0
		for _, h := range f.Inst {
			if l < len(f.Label) && f.Label[l].Value <= h.Start {
				fmt.Fprintf(w, "label_%x:\n", f.Label[l].Value)
				l++
			}
			fmt.Fprintf(w, "\t%s\n", xs.syntax(h))
			addr += uint64(h.Len)
		}
		fmt.Fprintf(w, "\n")
	}
}

func (xs *XS) syntax(inst *Inst) string {
	var str string
	if inst.Err != nil {
		str = fmt.Sprintf("# %v", inst.Err.Error())
	} else {
		switch inst.Op {
		case x86asm.CALL:
			switch {
			case isRel(inst):
				addr := getRel(inst)
				sym, _ := xs.lookupAddr(addr)
				if sym != nil {
					str = fmt.Sprintf("call %s", sym.Name)
				} else {
					str = fmt.Sprintf("call func_%x", addr)
				}
			default:
				str = x86asm.GNUSyntax(inst.Inst, 0, nil)
			}
		case x86asm.JMP, x86asm.JNE, x86asm.JE, x86asm.JA,
			x86asm.JB, x86asm.JBE, x86asm.JAE, x86asm.JLE,
			x86asm.JGE, x86asm.JG, x86asm.JS, x86asm.JNS:
			switch {
			case isRel(inst):
				rel := getRel(inst)
				op := strings.ToLower(inst.Op.String())
				str = fmt.Sprintf("%s label_%x", op, rel)
			}
		default:
			str = x86asm.GNUSyntax(inst.Inst, 0, nil)
		}
	}
	return fmt.Sprintf("%-64s # %#x % x", str, inst.Start, inst.Enc)
}

func isArg(inst *Inst, typ ...int) bool {
	var v int
	for i, a := range inst.Args {
		if i >= len(typ) {
			break
		}
		switch a.(type) {
		case x86asm.Reg:
			v = AREG
		case x86asm.Rel:
			v = AREL
		case x86asm.Mem:
			v = AMEM
		default:
			panic(fmt.Errorf("unhandled type %T", a))
		}

		if v != typ[i] {
			return false
		}
	}
	return true
}

func isBranch(inst *Inst) bool {
	switch inst.Op {
	case x86asm.JMP, x86asm.JNE, x86asm.JE, x86asm.JA,
		x86asm.JB, x86asm.JBE, x86asm.JAE, x86asm.JLE,
		x86asm.JGE, x86asm.JG, x86asm.JS, x86asm.JNS:
		return true
	}
	return false
}

func isRel(inst *Inst) bool {
	return (isBranch(inst) || inst.Op == x86asm.CALL) && isArg(inst, AREL)
}

func isAlpha(str string) bool {
	if strings.TrimSpace(str) == "" {
		return false
	}

	_, err := strconv.ParseInt(str, 0, 64)
	if err != nil {
		return true
	}
	return false
}

func getRel(inst *Inst) uint64 {
	if !isRel(inst) {
		return 0
	}
	return uint64(int64(inst.End) + int64(inst.Args[0].(x86asm.Rel)))
}

repository: qeedquan/debug

repo_name: qeedquan/debug

extension: go


text:
require ${PN}.inc

PR = "r1"

SRC_URI = "http://sources.openembedded.org/opie-1.2.4-split_core_applets_homeapplet.tar.bz2;name=split_core_applets_homeapplet \
           http://sources.openembedded.org/opie-1.2.4-split_pics.tar.bz2;name=split_pics \
           http://sources.openembedded.org/opie-1.2.4-split_apps.tar.bz2;name=split_apps"
SRC_URI[split_core_applets_homeapplet.md5sum] = "d8d1a4564a70983c1726cc923ac8c429"
SRC_URI[split_core_applets_homeapplet.sha256sum] = "7dde057f99b90d107e4fa81ba2af98bc0e3f2465987b649f2955f5138291b2c5"
SRC_URI[split_pics.md5sum] = "5499dc84b65395ab99bda6ed9d01ff0f"
SRC_URI[split_pics.sha256sum] = "f22781f36e84e12d51fff1eb68cc3fb98221c7d807a82226813b7e974a604109"
SRC_URI[split_apps.md5sum] = "67a43e8e4bcd9e63b884ea25deea5b34"
SRC_URI[split_apps.sha256sum] = "a33a55efb4ae4c15a8c2c5d6faba6d671a5652da8e216ce35088896fe597215b"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{epple2010new,
  title={A new approach to estimating the production function for housing},
  author={Epple, Dennis and Gordon, Brett and Sieg, Holger},
  journal={American Economic Review},
  volume={100},
  number={3},
  pages={905--24},
  year={2010}
}

@article{hausman1991identification,
  title={Identification and estimation of polynomial errors-in-variables models},
  author={Hausman, Jerry A and Newey, Whitney K and Ichimura, Hidehiko and Powell, James L},
  journal={Journal of Econometrics},
  volume={50},
  number={3},
  pages={273--295},
  year={1991},
  publisher={Elsevier}
}

gha_language: R


text:
SUMMARY = "Linux kernel module for apds9301 sensor"
LICENSE = "CLOSED"
inherit module
SRC_URI = "git://github.com/crispycookies/SSLYocto.git;protocol=https;branch=light-sense"
SRCREV = "${AUTOREV}"
S = "${WORKDIR}/git"
# The inherit of module . bbclass will automatically name module packages with
# " kernel - module -" prefix as required by the oe - core build environment .

repository: crispycookies/ssl-build

repo_name: crispycookies/ssl-build


text:
DESCRIPTION = "Time Sleuth"
SECTION = "opie/applications"
PRIORITY = "optional"
LICENSE = "GPL"
AUTHOR = "Dafydd Walters"
HOMEPAGE = "http://www.linux-solutions.at/projects/zaurus/applications-TimeSleuth.html"
PR = "r1"

SRC_URI = "http://handhelds.org/~zecke/oe_packages/timesleuth_V1.05ern.tar.gz "

PV = "1.05ern"
S = "${WORKDIR}/timesleuth_V${PV}"

APPNAME = "timesleuthqpe"
APPTYPE = "binary"
APPDESKTOP = "${S}"

do_install () {
	install -d ${D}${palmtopdir}/pics/
	install -m 0644 ${S}/*.png ${D}${palmtopdir}/pics/

}

inherit opie

SRC_URI[md5sum] = "671e48a9ff01de9cd2853a353b8179cb"
SRC_URI[sha256sum] = "f353a33e59a35f2667a00ce60998a06fa25948676dcb4a59599cf6518bd02ca6"


text:
LICENSE    = "GPL"

DEPENDS = "libosso libhildon gnome-vfs libhildonhelp"

SRC_URI = "http://repository.maemo.org/pool/os2008/free/source/h/hildon-control-panel/hildon-control-panel_2.0.1-1.tar.gz"

inherit autotools pkgconfig

FILES_${PN} += "${libdir}/dbus-1.0 ${datadir}/applications"

# pkg-config file will get broken after pkgconfig.bbclass work
#
# This code will fix it
#
#	sed -i -e 's:${STAGING_LIBDIR}/hildon:${libdir}/hildon:g' -e 's:${STAGING_DATADIR}/applications/hildon:${datadir}/applications/hildon:g' ${PKG_CONFIG_DIR}/hildon-control-panel.pc
#

SRC_URI[md5sum] = "b2247355c2fa3763904d698ec03ee78f"
SRC_URI[sha256sum] = "bc532113a4e4f4646fb523393e1c3da4dbd5cb2955f223bcbfc794216a7ab8b0"


text:
@article{RN1023,
 author = {Tong, S. Y. C. and Cheng, A. C. and Denholm, J. T.},
 doi = {10.1001/jamainternmed.2017.7947},
 issn = {2168-6114 (Electronic)
2168-6106 (Linking)},
 journal = {JAMA Intern Med},
 number = {2},
 pages = {295-296},
 title = {Immortal Time Bias in Assessing Evidence-Based Care Processes for Staphylococcus aureus Bacteremia},
 type = {Journal Article},
 url = {https://www.ncbi.nlm.nih.gov/pubmed/29404611},
 volume = {178},
 year = {2018}
}


text:
@incollection{AbstractionMethodsAnalysis_kuwahara_2010,
 abstract = {With advances in high throughput methods of data collection for gene regulatory networks, we are now in a position to face the challenge of elucidating how these genes coupled with environmental stimuli orchestrate the regulation of cell-level behaviors. Understanding the behavior of such complex sy...},
 author = {Kuwahara, Hiroyuki and Myers, Chris J.},
 booktitle = {Handbook of Research on Computational Methodologies in Gene Regulatory Networks},
 copyright = {Access limited to members},
 doi = {10.4018/978-1-60566-685-3.ch015},
 file = {C\:\\Users\\elros\\Zotero\\storage\\F9SN5M55\\Kuwahara_Myers-2010-Abstraction Methods for Analysis of Gene Regulatory Networks.pdf},
 isbn = {9781605666853},
 language = {en},
 pages = {352--385},
 publisher = {IGI Global},
 title = {Abstraction Methods for Analysis of Gene Regulatory Networks},
 year = {2010}
}


text:
require pcp.inc
inherit python3native native
#autotools-brokensep
DEPENDS = "python3-native python3-setuptools-native flex-native bison-native"

export PCP_DIR = "${D}"
export PCP_TMP_DIR = "${D}/tmp"
export PCP_BIN_DIR = "${D}/usr/bin"

B = "${S}"

do_configure:prepend() {
    export SED=${TMPDIR}/hosttools/sed
    export AR=${TMPDIR}/hosttools/ar
#    export PYTHON=python3

    rm -rf ${S}/include/pcp/configsz.h
    rm -rf ${S}/include/pcp/platformsz.h

}
do_compile:prepend() {
    sed -i -e "s,#undef HAVE_64BIT_LONG,,g" \
           -e "s,#undef HAVE_64BIT_PTR,,g" \
           -e "s,#undef PM_SIZEOF_SUSECONDS_T,,g" \
           -e "s,#undef PM_SIZEOF_TIME_T,,g" \
           ${S}/src/include/pcp/config.h.in

    export AR=${TMPDIR}/hosttools/ar
#    export PYTHON=python3
}

do_compile() {
        oe_runmake default_pcp
}

do_install () {
    oe_runmake install \
    PCP_ETC_DIR=${D}/${sysconfdir} \
    PCP_SYSCONF_DIR=${D}/${sysconfdir} \
    PCP_VAR_DIR=${D}/${localstatedir} \
    PCP_SHARE_DIR=${D}/${datadir} \
    PCP_BIN_DIR=${D}/${bindir} \
    PCP_BINADM_DIR=${D}/${libexecdir}/pcp/bin \
    PCP_LIBADM_DIR=${D}/${libdir} \
    PCP_LIB_DIR=${D}/${libdir} \
    PCP_MAN_DIR=${D}/${mandir} \
    PCP_DOC_DIR=${D}/${docdir}
}

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
require gtk+4.inc

MAJ_VER = "${@oe.utils.trim_version("${PV}", 2)}"

SRC_URI = "http://ftp.gnome.org/pub/gnome/sources/gtk/${MAJ_VER}/gtk-${PV}.tar.xz \
          "
SRC_URI[md5sum] = "d998a162cf326f4c764608c031e7d135"
SRC_URI[sha256sum] = "d5fbe6c29ebd47c791c3537376bb0cdf85ae559cc164cd1957b1b397b89dc2ae"

S = "${WORKDIR}/gtk-${PV}"

LIC_FILES_CHKSUM = "file://COPYING;md5=5f30f0716dfdd0d91eb439ebec522ec2 \
                    file://gtk/gtk.h;endline=25;md5=1d8dc0fccdbfa26287a271dce88af737 \
                    file://gdk/gdk.h;endline=25;md5=c920ce39dc88c6f06d3e7c50e08086f2 \
                    file://tests/testgtk.c;endline=25;md5=49d06770681b8322466b52ed19d29fb2"

repository: coldnew/yocto-bsp

repo_name: coldnew/yocto-bsp


text:
@article{iclabel2019,
 author = {Luca Pion-Tonachini and Ken Kreutz-Delgado and Scott Makeig},
 doi = {https://doi.org/10.1016/j.neuroimage.2019.05.026},
 journal = {NeuroImage},
 pages = {181-197},
 title = {ICLabel: An automated electroencephalographic independent component classifier, dataset, and website},
 volume = {198},
 year = {2019}
}

@inproceedings{WinklerEtAl2015,
 address = {{Milan}},
 author = {Winkler, Irene and Debener, Stefan and Müller, Klaus-Robert and Tangermann, Michael},
 booktitle = {Proceedings of {{EMBC}}-2015},
 doi = {10.1109/EMBC.2015.7319296},
 isbn = {978-1-4244-9271-8},
 pages = {4101-4105},
 publisher = {{IEEE}},
 title = {On the Influence of High-Pass Filtering on {{ICA}}-Based Artifact Reduction in {{EEG}}-{{ERP}}},
 year = {2015}
}

repository: mne-tools/mne-icalabel

repo_name: mne-tools/mne-icalabel

branch_name: refs/heads/main

gha_language: Python


text:
@inproceedings{KamathSSU19,
 author = {Kamath, Gautam and Sheffet, Or and Singhal, Vikrant and Ullman, Jonathan},
 booktitle = {Advances in Neural Information Processing Systems 32},
 month = {December},
 pages = {168--180},
 publisher = {Curran Associates, Inc.},
 series = {NeurIPS '19},
 title = {Differentially Private Algorithms for Learning Mixtures of Separated Gaussians},
 url = {https://arxiv.org/abs/1909.03951},
 year = {2019}
}

repository: TheSalon/academic-kickstart

repo_name: TheSalon/academic-kickstart


text:
# gem5 simulator source and checksum information

LIC_FILES_CHKSUM = "file://COPYING;md5=2d9514d69d8abf88b6e9125e759bf0ab \
                    file://LICENSE;md5=a585e2893cee63d16a1d8bc16c6297ec"

SRC_URI = "git://gem5.googlesource.com/public/gem5;protocol=https"

PV = "git${SRCPV}"

S = "${WORKDIR}/git"

SRCREV = "bcf041f257623e5c9e77d35b7531bae59edc0423"

BPN = "gem5-aarch64-native"

require gem5-aarch64-native.inc
require gem5-native.inc

repository: petegriffin/meta-arm

repo_name: petegriffin/meta-arm


text:
SUMMARY = "Photos & Videos app re-written from scratch in Enyo 2"
SECTION = "webos/apps"
LICENSE = "GPL-3.0-only"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-3.0-only;md5=c79ff39f19dfec6d293b95dea7b07891"

inherit webos_ports_repo
inherit allarch
inherit webos_enyojs_application
inherit webos_filesystem_paths
inherit webos_application

PV = "0.0.1+git${SRCPV}"
SRCREV = "25f39925b035f2d9f0b54e54b978e370f504b9c6"

SRC_URI = "${WEBOS_PORTS_GIT_REPO_COMPLETE}"
S = "${WORKDIR}/git"

repository: webOS-ports/meta-webos-ports

repo_name: webOS-ports/meta-webos-ports

branch_name: refs/heads/kirkstone


text:
# Copyright (c) 2013-2021 LG Electronics, Inc.

DESCRIPTION = "Notification Manager"
AUTHOR = "Suresh Arumugam <suresh.arumugam@lge.com>"
SECTION = "webos/base"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10 \
                    file://oss-pkg-info.yaml;md5=2bdfe040dcf81b4038370ae96036c519 \
"

DEPENDS = "glib-2.0 luna-service2 libpbnjson pmloglib boost libxml++"

inherit pkgconfig
inherit webos_cmake
inherit webos_system_bus
inherit webos_public_repo
inherit systemd

SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE:${PN} = "notificationmgr.service"

PV = "1.0.0-21+git${SRCPV}"
SRCREV = "97e68e38b489ab103e68b63672b5444ee7a05d49"

SRC_URI = "${WEBOSOSE_GIT_REPO_COMPLETE} \
file://0001-notificationmgr-Add-systemd-service-file.patch \
file://0002-Settings.cpp-Make-org.webosports-privileged-as-well.patch \
"
S = "${WORKDIR}/git"

FILES:${PN} += " \
    ${webos_prefix} \
"


text:
@misc{sc1,
  author = {Anthony Lee},
  title = {{Reproducibility}},
  howpublished = "\url{https://awllee.github.io/sc1-2019/reproducibility/}",
  year = {2019},
  note = "[Online; accessed 03-10-2019]"
}

@misc{Rpackages,
  author = {Friedrich Leisch},
  title = {Creating R packages: A tutorial},
  howpublished = "\url{https://cran.r-project.org/doc/contrib/Leisch-CreatingPackages.pdf}",
  year = {2009}
}

@misc{RpackageTut,
  author = {TutorialsPoint},
  title = {R - packages},
  howpublished = "\url{https://www.tutorialspoint.com/r/r_packages.htm}",
  year = {2019}
}

@misc{RExtensions,
  author = {CranRProject},
  title = {Writing R Extensions},
  howpublished = "\url{https://cran.r-project.org/doc/manuals/R-exts.html}",
  year = {2019}
}

@misc{PackageMetadata,
  author = {Hadley Wickham},
  title = {Package Metadata},
  howpublished = "\url{http://r-pkgs.had.co.nz/description.html}",
  year = {2019}}

@misc{Namespace,
author = {Hadley Wickham},
title = {Namespace},
howpublished = "\url{http://r-pkgs.had.co.nz/namespace.html#namespace}",
year = {2019}
}

@misc{GIT,
  title = {Getting Started - About version control},
  howpublished = "\url{https://git-scm.com/book/en/v2/Getting-Started-About-Version-Control}",
  year = {2019}}

@misc{shiny,
  title = {Shiny Documents},
  author = {Yihui Xie},
  howpublished = "\url{https://bookdown.org/yihui/rmarkdown/shiny-start.html}",
  year = {2019}
}

@misc{turingway,
  title = {The Turing Way},
  author = {Kirstie Whitaker},
  howpublished = "\url{https://the-turing-way.netlify.com/introduction/introduction}",
  year = {2019}}

repository: MauroCE/StatisticalComputingPortfolio

repo_name: MauroCE/StatisticalComputingPortfolio


text:
// Copyright 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package loader

import (
	"debug/elf"
)

// +stateify savable
type elfProgHeader struct {
	Type   elf.ProgType
	Flags  elf.ProgFlag
	Off    uint64
	Vaddr  uint64
	Paddr  uint64
	Filesz uint64
	Memsz  uint64
	Align  uint64
}

// savePhdrs is invoked by stateify.
func (v *VDSO) savePhdrs() []elfProgHeader {
	s := make([]elfProgHeader, 0, len(v.phdrs))
	for _, h := range v.phdrs {
		s = append(s, elfProgHeader(h))
	}
	return s
}

// loadPhdrs is invoked by stateify.
func (v *VDSO) loadPhdrs(s []elfProgHeader) {
	v.phdrs = make([]elf.ProgHeader, 0, len(s))
	for _, h := range s {
		v.phdrs = append(v.phdrs, elf.ProgHeader(h))
	}
}

repository: google/gvisor

repo_name: google/gvisor

gha_language: Go


text:
package smile

import (
	"compress/gzip"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strings"
	"testing"
)

func TestContext(t *testing.T) {
	w := httptest.NewRecorder()
	gz := gzip.NewWriter(w)
	defer gz.Close()

	post := url.Values{}
	post.Add("key1", "string1")
	post.Add("key1", "string2")
	post.Add("test", "test1")

	r := httptest.NewRequest("POST", "http://localhost/test?id=1", strings.NewReader(post.Encode()))
	r.Header["Content-Type"] = []string{"application/form-data;charset=utf-8"}
	r.PostForm = post
	r.Header["User-Agent"] = []string{"QQBrowser-1.0"}
	r.AddCookie(&http.Cookie{
		Name:     "testing",
		Value:    "hello world",
		Path:     "/",
		Domain:   "localhost",
		HttpOnly: false,
		Secure:   false,
	})

	e := Default()
	c := initContext(w, r, e)

	ip := c.GetClientIP()
	t.Log("IP:", ip)
	cookie, _ := c.GetCookie("testing")
	t.Log("cookie:", cookie)
	header := c.GetHeader()
	t.Log("header:", header)
	schema := c.GetScheme()
	t.Log("schema:", schema)
	proto := c.GetProto()
	t.Log("proto:", proto)
	uri := c.GetURL()
	t.Log("url:", uri)
	host := c.GetHost()
	t.Log("host", host)
	method := c.GetMethod()
	t.Log("method:", method)
	path := c.GetPath()
	t.Log("path", path)
	postKey := c.GetPostParam("test")
	t.Log("postKey-test:", postKey)
	postParams := c.GetMultipartFormParam("key1")
	t.Log("postParams-key1:", postParams)
	postFile := c.GetMultipartFormFile("key1")
	t.Log("post-Fil:", postFile)
	id := c.GetQueryParam("id")
	t.Log("queryParam-id:", id)
	queryS := c.GetQueryString()
	t.Log("queryString:", queryS)

	ua := c.GetUserAgent()
	t.Log("ua:", ua)
	rb := c.GetRawBody()
	t.Log("rb:", rb)

	c.WriteString("testing string")
	c.Flush()
	c.Done()

	c.SetHeader("resp", "testSetHeader")
	c.SetCookie(&http.Cookie{
		Name:     "SetHeader",
		Value:    "hello world",
		Path:     "/",
		Domain:   "localhost",
		HttpOnly: false,
		Secure:   false,
	})

}

func TestHandlerChain(t *testing.T) {

	w := httptest.NewRecorder()
	r := httptest.NewRequest("GET", "http://localhost/test?id=1", nil)

	c := initContext(w, r, Default())
	hc := newHandlerChain()
	n := 1
	for i := 1; i < 6; i++ {
		hc.add(func(c *Context) error {
			logi := n
			t.Log(logi)
			if n == 2 {
				t.Log(c.Abort())
			}
			n++
			return nil
		})
	}
	c.handlerChain = hc

	if err := c.Next(); err != nil {
		t.Error(err.Error())
	}
	hc.reset()
	if err := hc.next(c); err != nil {
		t.Error(err.Error())
	}
}

repository: kasiss-liu/smile

repo_name: kasiss-liu/smile


text:
SUMMARY = "Library used to query system info and statistics "
LICENSE = "LGPL-2.1"
LIC_FILES_CHKSUM = "file://COPYING;md5=435ed639f84d4585d93824e7da3d85da"

inherit lxqt

SRCREV = "23150e256bf4ab833c50477e462e5c78fb2e7525"
PV = "0.4.5"

branch_name: refs/heads/nilrt/master/hardknott


text:
@inproceedings{Scarpati:07,
 address = {St. Charles, Illinois, USA},
 author = {J. Scarpati and A. Wikström and O. Jönsson and R. Glav and
P. Händel and H. Hjalmarsson},
 booktitle = {SAE 2007 Noise and Vibration Conference},
 month = {May 15-17},
 organization = {},
 pages = {},
 title = {Prediction of Engine Noise using Parameterized Combustion Pressure Curves},
 year = {2007}
}

repository: hhjalmars/academic-kickstart

repo_name: hhjalmars/academic-kickstart


text:
# Copyright (C) 2015-2018 GENIVI Alliance
# Released under the MIT license (see COPYING.MIT for the terms)
SUMMARY = "GDP HVAC app with D-BUS interface"
HOMEPAGE = "https://github.com/GENIVI/HVAC"
LICENSE  = "MPL-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=9741c346eef56131163e13b9db1241b3"

DEPENDS = "qtbase qtdeclarative dbus"
RDEPENDS_${PN} = "qtquickcontrols-qmlplugins"

SRC_URI = "\
    git://github.com/GENIVI/HVAC \
    file://${APPLICATION_DESKTOP_FILE} \
"
SRCREV  = "dc5185223e7301807ce1a12c8f30528851fb4dc8"

APPLICATION_DESKTOP_FILE = "com.genivi.gdp.${PN}.desktop"
APPLICATION_BIN = "${B}/HVAC_rvi_vtc1010"
APPLICATION_ICON = "${S}/com.genivi.gdp.${PN}.svg"
APPLICATION_UNIT = "com.genivi.gdp.hvac"

require apps.inc

do_install_append() {
    install -d ${D}${APPLICATION_DIR_TARGET_PATH}/imports
    cp -fr ${S}/imports/* ${D}${APPLICATION_DIR_TARGET_PATH}/imports
}

repository: GENIVI/genivi-dev-platform

repo_name: GENIVI/genivi-dev-platform

gha_language: Shell