text:
require recipes-support/uhd/version.inc

FILESEXTRAPATHS_prepend := "${THISDIR}/files:"

ALLOW_EMPTY_${PN} = "1"

SRC_URI  = " \
    file://LICENSE.md \
"

LICENSE = "LGPLv3+"
LIC_FILES_CHKSUM = "file://${WORKDIR}/LICENSE.md;md5=2d2b59b2fc606f13eb2631fb80325865"

repository: EjonesNI/meta-ettus

repo_name: EjonesNI/meta-ettus


text:
require python-efl.inc
LICENSE = "LGPLv2.1"
LIC_FILES_CHKSUM = "file://COPYING;md5=fbc093901857fcd118f065f900982c24"
SRCREV = "${EFL_SRCREV}"
DEPENDS += "evas"

license: MIT

repository: lawwama/meta-oe

license_type: permissive

repo_name: lawwama/meta-oe

branch_name: refs/heads/master

extension: bb


text:
var Promise = require('bluebird');

module.exports = {

	/**
	 * Take the results from a resolved promise, and send each result through a given task.
	 * Returns a single promise that will be resolved once all sub-tasks have completed.
	 *
	 * @param  {function} task task to be executed for each result.
	 * @return {Promise}  Promise to execute task for each result.
	 */
	forEachResult: function(task) {
		return function(results) {
			return Promise.map(results, task);
		}
	},

	/**
	 * Wrapper to simplify common chained promise pattern
	 *
	 * @param  {function} resolver instructions to follow for executing promise.
	 * @return {Promise} Promise to execute instructions, once parent function is called.
	 */
	chainablePromise: function(resolver) {
	  return function() {
	    return new Promise(resolver);
	  };
	},

	/**
	 * Make a function wrapper for a function that needs to be called at a later time, but that you would like
	 * to give certain parameters now.  Helps in promise chains.
	 *
	 * @return {function} function you want called as part of a promise change, but you want to give params now.
	 */
	callFn: function() {
		var args = Array.prototype.slice.call(arguments);
			params = args.length > 1 ? args.slice(1) : [];

		return function() {
			return args[0].apply(this, params);
		};
	},

	/**
	 * Generic callback handler for resolving a promise once a call has completed.
	 *
	 * @param  {function} resolve resolve function for Promise that is to be resolved.
	 * @param  {string} errPrefix String prefix for error message if call fails and an error is returned.
	 */
	genericCallbackResolver: function(resolve, errPrefix) {
	  return function(err, result) {
	    if (err) {
	      console.log(errPrefix || "genericCallbackResolver()", err);
	    }
	    resolve(result);
	  };
	}
}

license: ISC

extension: js


text:
@inproceedings{andersen2008accountable,
  title={Accountable internet protocol (aip)},
  author={Andersen, David G and Balakrishnan, Hari and Feamster, Nick and Koponen, Teemu and Moon, Daekyeong and Shenker, Scott},
  booktitle={ACM SIGCOMM Computer Communication Review},
  year={2008},
  organization={ACM},
  url={https://www.cs.cmu.edu/~dga/papers/aip-sigcomm2008.pdf},
  note={Network design for self-certifying addresses. Scheme is like
    source-routing, with signing domains envisioned at an ASN level.}
}

@inproceedings{beverly2005spoofer,
  title={The Spoofer project: Inferring the extent of source address filtering on the Internet},
  author={Beverly, Robert and Bauer, Steven},
  booktitle={USENIX SRUTI},
  volume={5},
  year={2005},
  organization={USENIX},
  url={http://static.usenix.org/legacy/events/sruti05/tech/full_papers/beverly/beverly_html/},
  note={A project monitoring how much of the IPv4 Address space is capable of
    spoofing, along with a client for testing your capabilities. Now hosted at
    https://www.caida.org/projects/spoofer/}
}

@inproceedings{guha2004nutss,
  title={NUTSS: A SIP-based approach to UDP and TCP network connectivity},
  author={Guha, Saikat and Takeda, Yutaka and Francis, Paul},
  booktitle={Proceedings of the ACM SIGCOMM workshop on Future directions in network architecture},
  year={2004},
  organization={ACM},
  url={http://www.mpi-sws.org/~francis/fdna02-guha1.pdf},
  notes={A description of a protocol for TCP hole-punching through a modified
    ICE scheme, which makes use of the ability of the coordinating server to
    spoof packets to help complete TCP handshakes on behalf of the NAT'ed
    clients in order to establish connectivity.}
}

extension: bib


text:
// Copyright 2017 Granitic. All rights reserved.
// Use of this source code is governed by an Apache 2.0 license that can be found in the LICENSE file at the root of this project.

package event

import (
	"github.com/vlorc/gioc/invoker"
	"github.com/vlorc/gioc/types"
	"strings"
)

func (el *CoreEventListener) On(event string, fn interface{}) error {
	return el.on(el.provider, event, fn)
}

func (el *CoreEventListener) Emit(event string, params ...interface{}) error {
	return el.EmitWith(el.provider, event, params...)
}

func (el *CoreEventListener) OnWith(provider func() types.Provider, event string, fn interface{}) error {
	return el.on(provider, event, func() types.Invoker {
		return invoker.NewInvokerWith(provider, toInvoker(fn))
	})
}

func (el *CoreEventListener) EmitWith(provider func() types.Provider, event string, params ...interface{}) error {
	f := el.get(event)
	if len(f) == 0 {
		return nil
	}

	p := provider()
	for _, v := range f {
		v.ApplyWith(p, params...)
	}
	return nil
}

func (el *CoreEventListener) on(provider func() types.Provider, event string, fn interface{}) error {
	pos := strings.LastIndex(event, "::")
	if pos > 0 {
		var listener types.EventListener
		provider().Load(&listener, event[:pos])
		return listener.On(event[pos+2:], fn)
	}
	if 0 == pos {
		event = event[2:]
	}
	el.set(event, toInvoker(fn))
	return nil
}

func (el *CoreEventListener) set(event string, inv types.Invoker) {
	el.lock.Lock()
	defer el.lock.Unlock()

	if "*" == event {
		el.defaults = append(el.defaults, inv)
	} else {
		el.listeners[event] = append(el.listeners[event], inv)
	}
}

func (el *CoreEventListener) get(event string) []types.Invoker {
	el.lock.RLock()
	inv, ok := el.listeners[event]
	el.lock.RUnlock()
	if !ok {
		inv = el.defaults
	}
	return inv
}

func toInvoker(fn interface{}) types.Invoker {
	var inv types.Invoker
	switch r := fn.(type) {
	case types.Invoker:
		inv = r
	case func() types.Invoker:
		inv = r()
	default:
		inv = invoker.NewInvoker(fn, nil)
	}
	return inv
}

repository: vlorc/gioc

repo_name: vlorc/gioc

gha_language: Go

extension: go


text:
@article{MaJ-MRSRL-DiagnosticImageClassification,
    author = {Ma, Jeffrey Jian
              and Nakarmi, Ukash
              and Yue Sik Kin, Cedric
              and Sandino, Christopher
              and Cheng, Joseph Y.
              and Syed, Ali B.
              and Wei, Peter
              and Pauly, John M.
              and Vasanawala, Shreyas},
    author+an = {1=highlight},
    title = {Diagnostic Image Quality Assessment and Classification in Medical Imaging: Opportunities and Challenges},
    journal = {Proceedings of the 2020 IEEE 17th International Symposium on Biomedical Imaging (ISBI)},
    year = {2020},
    month = {5},
    day = {22},
    volume = {26},
    pages = {337--340},
    doi = {10.1109/ISBI45749.2020.9098735},
    url = {https://doi.org/10.1109/ISBI45749.2020.9098735},
    eprint_url = {https://ieeexplore.ieee.org/document/9098735},
    addendum = {Full Paper},
    abstract = {The prosperity of location-based social networking has paved the way for new applications of group-based activity planning and marketing. While such applications heavily rely on geo-social group queries (GSGQs), existing studies fail to produce a cohesive group in terms of user acquaintance. In this paper, we propose a new family of GSGQs with minimum acquaintance constraints. They are more appealing to users as they guarantee a worst-case acquaintance level in the result group. For efficient processing of GSGQs on large location-based social networks, we devise two social-aware spatial index structures, namely SaR-tree and SaR*-tree. The latter improves on the former by considering both spatial and social distances when clustering objects. Based on SaR-tree and SaR*-tree, novel algorithms are developed to process various GSGQs. Extensive experiments on real datasets Gowalla and Twitter show that our proposed methods substantially outperform the baseline algorithms under various system settings.},
    keywords = {selected},
}

@article{MaJ-TheWallLab-DiagnosticImageClassification-Autism,
    author = {Nag, Anish
              and Haber, Nick
              and Voss, Catalin
              and Tamura, Serena
              and Daniels, Jena
              and Ma, Jeffrey Jian
              and Chiang, Bryan
              and Ramachandran, Shasta
              and Schwartz, Jessey
              and Winograd, Terry
              and Feinstein, Carl
              and Wall, Dennis P},
    author+an = {6=highlight},
    title = {Toward Continuous Social Phenotyping: Analyzing Gaze Patterns in an Emotion Recognition Task for Children With Autism Through Wearable Smart Glasses},
    journal = {Journal of Medical Internet Research (JMIR)},
    year = {2020},
    month = {4},
    day = {22},
    volume = {22},
    number = {4},
    pages = {337--340},
    doi = {10.2196/13810},
    url = {https://doi.org/10.2196/13810},
    eprint_url = {https://www.jmir.org/2020/4/e13810/},
    addendum = {Journal Paper},
    abstract = {Several studies have shown that facial attention differs in children with autism. Measuring eye gaze and emotion recognition in children with autism is challenging, as standard clinical assessments must be delivered in clinical settings by a trained clinician. Wearable technologies may be able to bring eye gaze and emotion recognition into natural social interactions and settings.},
    keywords = {selected},
}

% @inproceedings{ICDE21:blockchain-keyword-search,
%     author = {Zhang, Ce
%               and Xu, Cheng
%               and Wang, Haixin
%               and Xu, Jianliang
%               and Choi, Byron},
%     author+an = {2=highlight,dagger;1=dagger},
%     title = {Authenticated Keyword Search in Scalable Hybrid-Storage Blockchains},
%     booktitle = {Proceedings of the 37th IEEE International Conference on Data Engineering (\textbf{ICDE '21})},
%     year = {2021},
%     month = {4},
%     address = {Chania, Crete, Greece},
%     eprint_url = {https://xuc.me/file/paper/ICDE21.pdf},
%     addendum = {Full Paper},
%     abstract = {Blockchain has emerged as a promising solution for secure data storage and retrieval for decentralized applications. To scale blockchain systems, a prevailing approach is to employ a hybrid storage model, where only small meta-data are stored on-chain while the raw data are outsourced to an off-chain storage service provider. The key issue for query processing in such a system is the design of \emph{gas}-efficient authenticated data structure (ADS) to authenticate the query results. In this paper, we study novel ADS schemes for authenticated keyword search in hybrid-storage blockchains. We first propose the suppressed Merkle inverted (Merkle$^{inv}$) index, which maintains only a partial ADS structure on-chain that can be securely updated with a logarithm-sized cryptographic proof. Moreover, we propose a Chameleon inverted (Chameleon$^{inv}$) index that leverages the chameleon vector commitment to achieve a constant maintenance cost. It is further optimized with Bloom filters to enhance the query and verification performance. We prove the security of the proposed ADS schemes and evaluate their performance using real datasets on the Ethereum platform. Experimental results show that, compared to a baseline solution, the proposed Merkle$^{inv}$ and Chameleon$^{inv}$ indexes reduce the average on-chain maintenance cost from US\$11.21 down to US\$2.69 and US\$0.24, respectively, without sacrificing much the query performance.},
%     keywords = {selected},
% }

% @inproceedings{ICDE21:blockchain-keyword-search,
%     author = {Zhang, Ce
%               and Xu, Cheng
%               and Wang, Haixin
%               and Xu, Jianliang
%               and Choi, Byron},
%     author+an = {2=highlight,dagger;1=dagger},
%     title = {Authenticated Keyword Search in Scalable Hybrid-Storage Blockchains},
%     booktitle = {Proceedings of the 37th IEEE International Conference on Data Engineering (\textbf{ICDE '21})},
%     year = {2021},
%     month = {4},
%     address = {Chania, Crete, Greece},
%     eprint_url = {https://xuc.me/file/paper/ICDE21.pdf},
%     addendum = {Full Paper},
%     abstract = {Blockchain has emerged as a promising solution for secure data storage and retrieval for decentralized applications. To scale blockchain systems, a prevailing approach is to employ a hybrid storage model, where only small meta-data are stored on-chain while the raw data are outsourced to an off-chain storage service provider. The key issue for query processing in such a system is the design of \emph{gas}-efficient authenticated data structure (ADS) to authenticate the query results. In this paper, we study novel ADS schemes for authenticated keyword search in hybrid-storage blockchains. We first propose the suppressed Merkle inverted (Merkle$^{inv}$) index, which maintains only a partial ADS structure on-chain that can be securely updated with a logarithm-sized cryptographic proof. Moreover, we propose a Chameleon inverted (Chameleon$^{inv}$) index that leverages the chameleon vector commitment to achieve a constant maintenance cost. It is further optimized with Bloom filters to enhance the query and verification performance. We prove the security of the proposed ADS schemes and evaluate their performance using real datasets on the Ethereum platform. Experimental results show that, compared to a baseline solution, the proposed Merkle$^{inv}$ and Chameleon$^{inv}$ indexes reduce the average on-chain maintenance cost from US\$11.21 down to US\$2.69 and US\$0.24, respectively, without sacrificing much the query performance.},
%     keywords = {selected},
% }


text:
@Article{ BlaKah:1980,
	author = {Olivier Jean Blanchard and Charles M Kahn},
	title = {The Solution of Linear Difference Models under Rational Expectations},
	journal = {Econometrica},
	year = {1980},
	volume = {48},
	number = {5},
	pages = {1305--11},
	month = {July}
}

@TechReport{ Uhl:1995,
	author = {H. Uhlig},
	title = {A toolkit for analyzing nonlinear dynamic stochastic models easily},
	year = {1995},
	month = {},
	institution = {Tilburg University, Center for Economic Research},
	type = {Discussion Paper},
	number = {97}
}

@Article{ Kle:2000,
	author = {Paul Klein},
	title = {Using the generalized Schur form to solve a multivariate linear rational expectations model},
	journal = {Journal of Economic Dynamics and Control},
	year = {2000},
	volume = {24},
	number = {10},
	pages = {1405--1423},
	month = {September}
}

@TechReport{ Jui:2001,
	author={Michel Juillard},
	title={DYNARE: A program for the simulation of rational expectation models},
	year={2001},
	month={Apr},
	institution={Society for Computational Economics},
	type={Computing in Economics and Finance 2001},
	number={213}
}

@Article{ KinWat:2002,
	author={King, Robert G and Watson, Mark W},
	title={System Reduction and Solution Algorithms for Singular Linear Difference Systems under Rational Expectations},
	journal={Computational Economics},
	year={2002},
	volume={20},
	number={1-2},
	pages={57-86},
	month={October}
}

@Article{ SchUri:2004,
	author = {Stephanie Schmitt-Grohe and Martin Uribe},
	title = {Solving dynamic general equilibrium models using a second-order approximation to the policy function},
	journal = {Journal of Economic Dynamics and Control},
	year = {2004},
	volume = {28},
	number = {4},
	pages = {755--775},
	month = {January}
}

@TechReport{ KimKimSchSim:2005,
	author={Henry Kim and Jinill Kim and Ernst Schaumburg and Christopher A. Sims},
	title={Calculating and Using Second Order Accurate Solutions of Discrete Time Dynamic Equilibrium Models},
	year={2005},
	month={} ,
	institution={Department of Economics, Tufts University},
	type={Discussion Papers Series, Department of Economics, Tufts University},
	number={0505}
}

@Article{ GomKle:2012,
	author={Gomme, Paul and Klein, Paul},
	title={Second-order approximation of dynamic models without the use of tensors},
	journal={Journal of Economic Dynamics and Control},
	year={2011},
	volume={35},
	number={4},
	pages={604-615},
	month={April}
}

@Article{ ChrEicEva:2005,
	AUTHOR = {Martin Eichenbaum, Lawrence J. Christiano, Charles L. Evans},
	TITLE = {Nominal Rigidities and the Dynamic Effects of a Shock to Monetary Policy},
	JOURNAL = {Journal of Political Economy},
	YEAR = {2005},
	VOLUME = {113},
	NUMBER = {1},
	PAGES = {1--45},
	MONTH = {February}
}

@Book{Lan:2009,
	author = {Langtangen, Hans Petter},
	title = {Python Scripting for Computational Science},
	year = {2009},
	isbn = {3540739157, 9783540739159},
	edition = {3rd},
	publisher = {Springer Publishing Company, Incorporated},
}

@Article{CoeReyWin:2011,
	author={Nicolas Coeurdacier and Helene Rey and Pablo Winant},
	title={The Risky Steady State},
	journal={American Economic Review},
	year=2011,
	volume={101},
	number={3},
	pages={398-401},
	month={May}
}

@book{Mcc:2008,
	title={The ABCs of RBCs: An Introduction to Dynamic Macroeconomic Models},
	author={McCandless, G.T.},
	isbn={9780674028142},
	lccn={07061809},
	url={http://books.google.com.hk/books?id=e4h5QgAACAAJ},
	year={2008},
	publisher={Harvard University Pres}
}

repository: wenyifdu/pymaclab

repo_name: wenyifdu/pymaclab


text:
require pixman.inc
PR = "${INC_PR}.1"

SRC_URI[archive.md5sum] = "532db4194e18c108d0b7dd85f20d39b8"
SRC_URI[archive.sha256sum] = "1484092277c5187f5458229a2b7fd7fbc0cb07e1f220c7f8f9ac65de6dba7989"
SRC_URI += "\
           file://0001-Generic-C-implementation-of-pixman_blt-with-overlapp.patch\
           file://0002-Support-of-overlapping-src-dst-for-pixman_blt_mmx.patch\
           file://0003-Support-of-overlapping-src-dst-for-pixman_blt_sse2.patch\
           file://0004-Support-of-overlapping-src-dst-for-pixman_blt_neon.patch\
           file://0005-ARM-added-NEON-optimizations-for-fetch-store-r5g6b5-.patch\
           file://0006-A-copy-paste-version-of-16bpp-bilinear-scanline-fetc.patch\
           file://0007-ARM-added-missing-cache-preload.patch\
           file://565-over-neon.patch \
           file://neon-reverse-u.patch \
"

NEON = " --disable-arm-neon "
NEON_armv7a = " "

EXTRA_OECONF = "${NEON} --disable-gtk"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
require dnsmasq.inc

SRC_URI[dnsmasq-2.85.md5sum] = "4079e1e6e1065e4bd14ded268cdd7bd7"
SRC_URI[dnsmasq-2.85.sha256sum] = "f36b93ecac9397c15f461de9b1689ee5a2ed6b5135db0085916233053ff3f886"
SRC_URI += "\
    file://lua.patch \
"

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott

gha_license_id: MIT

gha_language: BitBake


text:
PR = "r3"

SRC_URI = "http://www.soft-switch.org/downloads/spandsp/spandsp-${PV}.tgz"

# *cough*
do_configure_append() {
        rm config.log
}

require spandsp.inc


text:
package driver;

// Operations dealing with groups in the filesystem.

import (
    "github.com/pkg/errors"

    "github.com/eriq-augustine/elfs/identity"
)

func (this *Driver) GetGroups() map[identity.GroupId]*identity.Group {
    return this.groups;
}

func (this *Driver) AddGroup(contextUser identity.UserId, name string) (identity.GroupId, error) {
    if (name == "") {
        return identity.EMPTY_GROUP_ID, errors.WithStack(NewIllegalOperationError("Cannot create group with no name."));
    }

    for _, groupInfo := range(this.groups) {
        if (groupInfo.Name == name) {
            return identity.EMPTY_GROUP_ID, errors.WithStack(NewIllegalOperationError("Cannot create group with existing name: " + name));
        }
    }

    newGroup := identity.NewGroup(this.getNewGroupId(), name, contextUser, false);

    this.groups[newGroup.Id] = newGroup;
    this.cache.CacheGroupPut(newGroup);

    return newGroup.Id, nil;
}

func (this *Driver) DeleteGroup(contextUser identity.UserId, groupId identity.GroupId) error {
    groupInfo, ok := this.groups[groupId];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Cannot remove unknown group."));
    }

    if (groupInfo.IsUsergroup) {
        return errors.WithStack(NewIllegalOperationError("Cannot remove usergroup (must remove user instead)."));
    }

    // Only the group's owner (or root) can remove it.
    if (contextUser != groupInfo.Owner || contextUser != identity.ROOT_USER_ID) {
        return errors.WithStack(NewIllegalOperationError("Only owner or root can remove a group."));
    }

    // Remove this group from the fat.
    this.purgeGroup(groupId);

    delete(this.groups, groupId);
    this.cache.CacheGroupDelete(groupInfo);

    return nil;
}

func (this *Driver) JoinGroup(contextUser identity.UserId, targetUser identity.UserId, groupId identity.GroupId) error {
    groupInfo, ok := this.groups[groupId];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Cannot join an unknown group."));
    }

    _, ok = this.users[targetUser];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Group join candidate does not exist."));
    }

    // Only the owner or root can add people to groups.
    if (contextUser != groupInfo.Owner || contextUser != identity.ROOT_USER_ID) {
        return errors.WithStack(NewIllegalOperationError("Only owner or root can add to a group."));
    }

    if (groupInfo.HasMember(targetUser)) {
        return nil;
    }

    groupInfo.Members[targetUser] = true;
    this.cache.CacheGroupPut(groupInfo);

    return nil;
}

func (this *Driver) KickUser(contextUser identity.UserId, targetUser identity.UserId, groupId identity.GroupId) error {
    groupInfo, ok := this.groups[groupId];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Cannot kick from an unknown group."));
    }

    _, ok = this.users[targetUser];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Kick candidate does not exist."));
    }

    if (targetUser == groupInfo.Owner && groupInfo.IsUsergroup) {
        return errors.WithStack(NewIllegalOperationError("Cannot kick the owner of a usergroup."));
    }

    // Only the owner or root can add people to groups.
    if (contextUser != groupInfo.Owner || contextUser != identity.ROOT_USER_ID || contextUser == targetUser) {
        return errors.WithStack(NewIllegalOperationError("Only owner, root, or self can kick from a group."));
    }

    if (!groupInfo.Members[targetUser]) {
        return nil;
    }

    // If the owner was kicked, root becomes the new owner.
    // However, usergroups cannot kick/change owners.
    if (targetUser == groupInfo.Owner) {
        groupInfo.Owner = identity.ROOT_USER_ID;
    }

    delete(groupInfo.Members, targetUser);
    this.cache.CacheGroupPut(groupInfo);

    return nil;
}

// Promote a user to be the owner of a group.
func (this *Driver) PromoteUser(contextUser identity.UserId, targetUser identity.UserId, groupId identity.GroupId) error {
    groupInfo, ok := this.groups[groupId];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Cannot promote in unknown group."));
    }

    if (groupInfo.Owner == targetUser) {
        return nil;
    }

    // Usergroups cannot have a different owner.
    if (groupInfo.IsUsergroup) {
        return errors.WithStack(NewIllegalOperationError("Usergroups cannot have a different owner."));
    }

    _, ok = this.users[targetUser];
    if (!ok) {
        return errors.WithStack(NewIllegalOperationError("Promotion candidate does not exist."));
    }

    // Only the owner or root can promote.
    if (contextUser != groupInfo.Owner || contextUser != identity.ROOT_USER_ID) {
        return errors.WithStack(NewIllegalOperationError("Only owner or root can add to a group."));
    }

    // The candidate must already be in the group.
    if (!groupInfo.Members[targetUser]) {
        return errors.WithStack(NewIllegalOperationError("Promotion candidate is not a member of the group."));
    }

    groupInfo.Owner = targetUser;
    this.cache.CacheGroupPut(groupInfo);

    return nil;
}

// Go through the entire FAT and ensure that there are no traces of this group.
// When a group is removed, the dirent get's the owner's usergroup.
func (this *Driver) purgeGroup(groupId identity.GroupId) {
    for _, direntInfo := range(this.fat) {
        if (direntInfo.Group == groupId) {
            direntInfo.Group = this.users[direntInfo.Owner].Usergroup;
        }
    }
}

repository: eriq-augustine/elfs

repo_name: eriq-augustine/elfs


text:
# Copyright 2020 iWave Systems Technologies

require recipes-bsp/imx-mkimage/imx-boot_1.0.bb

DEPENDS_remove = "imx-atf"
DEPENDS += " iwg33m-atf"

do_compile[depends]_remove = "imx-atf:do_deploy"
do_compile[depends] += "iwg33m-atf:do_deploy"

DTBS ?= "${@d.getVar('UBOOT_DTB_NAME').partition('-')[2]}"

do_compile() {
    compile_${SOC_FAMILY}
    # Copy TEE binary to SoC target folder to mkimage
    if ${DEPLOY_OPTEE}; then
        cp ${DEPLOY_DIR_IMAGE}/tee.bin                       ${BOOT_STAGING}
    fi
    # mkimage for i.MX8
    for target in ${IMXBOOT_TARGETS}; do
        if [ "$target" = "flash_linux_m4_no_v2x" ]; then
           # Special target build for i.MX 8DXL with V2X off
           bbnote "building ${SOC_TARGET} - ${REV_OPTION} V2X=NO ${target}"
           make SOC=${SOC_TARGET} ${REV_OPTION} V2X=NO  flash_linux_m4
        else
           bbnote "building ${SOC_TARGET} - ${REV_OPTION} ${target}"
           make SOC=${SOC_TARGET} ${REV_OPTION} ${target}
        fi
        if [ -e "${BOOT_STAGING}/flash.bin" ]; then
            cp ${BOOT_STAGING}/flash.bin ${S}/${BOOT_CONFIG_MACHINE}-${target}
        fi
    done
}