Upload folder using huggingface_hub (part 109)

pool/shard010/C/0138063_exp2.c

@@ -0,0 +1,184 @@
+/* mpfr_exp2 -- power of 2 function 2^y
+
+Copyright 2001-2021 Free Software Foundation, Inc.
+Contributed by the AriC and Caramba projects, INRIA.
+
+This file is part of the GNU MPFR Library.
+
+The GNU MPFR Library is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 3 of the License, or (at your
+option) any later version.
+
+The GNU MPFR Library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the GNU MPFR Library; see the file COPYING.LESSER.  If not, see
+https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
+
+#define MPFR_NEED_LONGLONG_H
+#include "mpfr-impl.h"
+
+/* TODO: mpfr_get_exp_t is called 3 times, with 3 different directed
+   rounding modes. One could reduce it to only one call thanks to the
+   inexact flag, but is it worth? */
+
+/* Convert x to an mpfr_eexp_t integer, with saturation at the minimum
+   and maximum values. Flags are unchanged. */
+static mpfr_eexp_t
+round_to_eexp_t (mpfr_srcptr x, mpfr_rnd_t rnd_mode)
+{
+  mpfr_flags_t flags = __gmpfr_flags;
+  mpfr_eexp_t e;
+
+  e = mpfr_get_exp_t (x, rnd_mode);
+  __gmpfr_flags = flags;
+  return e;
+}
+
+/* The computation of y = 2^z is done by                           *
+ *     y = exp(z*log(2)). The result is exact iff z is an integer. */
+
+int
+mpfr_exp2 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
+{
+  int inexact;
+  mpfr_eexp_t xint;  /* note: will fit in mpfr_exp_t */
+  mpfr_t xfrac;
+  MPFR_SAVE_EXPO_DECL (expo);
+
+  MPFR_LOG_FUNC
+    (("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec(x), mpfr_log_prec, x, rnd_mode),
+     ("y[%Pu]=%.*Rg inexact=%d", mpfr_get_prec(y), mpfr_log_prec, y,
+      inexact));
+
+  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
+    {
+      if (MPFR_IS_NAN (x))
+        {
+          MPFR_SET_NAN (y);
+          MPFR_RET_NAN;
+        }
+      else if (MPFR_IS_INF (x))
+        {
+          if (MPFR_IS_POS (x))
+            MPFR_SET_INF (y);
+          else
+            MPFR_SET_ZERO (y);
+          MPFR_SET_POS (y);
+          MPFR_RET (0);
+        }
+      else /* 2^0 = 1 */
+        {
+          MPFR_ASSERTD (MPFR_IS_ZERO(x));
+          return mpfr_set_ui (y, 1, rnd_mode);
+        }
+    }
+
+  /* Since the smallest representable non-zero float is 1/2 * 2^emin,
+     if x <= emin - 2, the result is either 1/2 * 2^emin or 0.
+     Warning, for emin - 2 < x < emin - 1, we cannot conclude, since 2^x
+     might round to 2^(emin - 1) for rounding away or to nearest, and there
+     might be no underflow, since we consider underflow "after rounding". */
+
+  if (MPFR_UNLIKELY (round_to_eexp_t (x, MPFR_RNDU) <= __gmpfr_emin - 2))
+    return mpfr_underflow (y, rnd_mode == MPFR_RNDN ? MPFR_RNDZ : rnd_mode, 1);
+
+  if (MPFR_UNLIKELY (round_to_eexp_t (x, MPFR_RNDD) >= __gmpfr_emax))
+    return mpfr_overflow (y, rnd_mode, 1);
+
+  /* We now know that emin - 2 < x < emax. Note that an underflow or
+     overflow is still possible (we have eliminated only easy cases). */
+
+  MPFR_SAVE_EXPO_MARK (expo);
+
+  /* 2^x = 1 + x*log(2) + O(x^2) for x near zero, and for |x| <= 1 we have
+     |2^x - 1| <= x < 2^EXP(x). If x > 0 we must round away from 0 (dir=1);
+     if x < 0 we must round toward 0 (dir=0). */
+  MPFR_SMALL_INPUT_AFTER_SAVE_EXPO (y, __gmpfr_one, - MPFR_GET_EXP (x), 0,
+                                    MPFR_IS_POS (x), rnd_mode, expo, {});
+
+  xint = mpfr_get_exp_t (x, MPFR_RNDZ);
+  MPFR_ASSERTD (__gmpfr_emin - 2 < xint && xint < __gmpfr_emax);
+
+  mpfr_init2 (xfrac, MPFR_PREC (x));
+  MPFR_DBGRES (inexact = mpfr_frac (xfrac, x, MPFR_RNDN));
+  MPFR_ASSERTD (inexact == 0);
+
+  if (MPFR_IS_ZERO (xfrac))
+    {
+      /* Here, emin - 1 <= x <= emax - 1, so that an underflow or overflow
+         will not be possible. */
+      mpfr_set_ui (y, 1, MPFR_RNDN);
+      inexact = 0;
+    }
+  else
+    {
+      /* Declaration of the intermediary variable */
+      mpfr_t t;
+
+      /* Declaration of the size variable */
+      mpfr_prec_t Ny = MPFR_PREC(y);              /* target precision */
+      mpfr_prec_t Nt;                             /* working precision */
+      mpfr_exp_t err;                             /* error */
+      MPFR_ZIV_DECL (loop);
+
+      /* compute the precision of intermediary variable */
+      /* the optimal number of bits : see algorithms.tex */
+      Nt = Ny + 5 + MPFR_INT_CEIL_LOG2 (Ny);
+
+      /* initialize of intermediary variable */
+      mpfr_init2 (t, Nt);
+
+      /* First computation */
+      MPFR_ZIV_INIT (loop, Nt);
+      for (;;)
+        {
+          /* compute exp(x*ln(2))*/
+          mpfr_const_log2 (t, MPFR_RNDU);       /* ln(2) */
+          mpfr_mul (t, xfrac, t, MPFR_RNDU);    /* xfrac * ln(2) */
+          err = Nt - (MPFR_GET_EXP (t) + 2);   /* Estimate of the error */
+          mpfr_exp (t, t, MPFR_RNDN);           /* exp(xfrac * ln(2)) */
+
+          if (MPFR_LIKELY (MPFR_CAN_ROUND (t, err, Ny, rnd_mode)))
+            break;
+
+          /* Actualisation of the precision */
+          MPFR_ZIV_NEXT (loop, Nt);
+          mpfr_set_prec (t, Nt);
+        }
+      MPFR_ZIV_FREE (loop);
+
+      inexact = mpfr_set (y, t, rnd_mode);
+
+      mpfr_clear (t);
+    }
+
+  mpfr_clear (xfrac);
+
+  if (MPFR_UNLIKELY (rnd_mode == MPFR_RNDN && xint == __gmpfr_emin - 1 &&
+                     MPFR_GET_EXP (y) == 0 && mpfr_powerof2_raw (y)))
+    {
+      /* y was rounded down to 1/2 and the rounded value with an unbounded
+         exponent range would be 2^(emin-2), i.e. the midpoint between 0
+         and the smallest positive FP number. This is a double rounding
+         problem: we should not round to 0, but to (1/2) * 2^emin. */
+      MPFR_SET_EXP (y, __gmpfr_emin);
+      inexact = 1;
+      MPFR_SAVE_EXPO_UPDATE_FLAGS (expo, MPFR_FLAGS_UNDERFLOW);
+    }
+  else
+    {
+      /* The following is OK due to early overflow/underflow checking.
+         the exponent may be slightly out-of-range, but this will be
+         handled by mpfr_check_range. */
+      MPFR_EXP (y) += xint;
+    }
+
+  MPFR_SAVE_EXPO_FREE (expo);
+  return mpfr_check_range (y, inexact, rnd_mode);
+}

pool/shard010/C/0138064_dev_led_pwm.c

@@ -0,0 +1,117 @@
+/*
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2016 Nels D. "Chip" Pearson (aka CmdrZin)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * dev_led_1.c
+ *
+ * Created: 2/24/2016		0.01	ndp
+ *  Author: Chip
+ */ 
+
+#include <avr/io.h>
+#include <stdbool.h>
+#include <avr/interrupt.h>
+
+#include "sysTimer.h"
+#include "access.h"
+
+#include "dev_led_pwm.h"
+
+#define DEMO_BOARD	0					// Use for testing. Set to 0 for proto-board set up.
+
+bool	dlp_state;
+int		dlp_rate;
+int		dlp_rateAdjust;					// Controls how fast the glow cycles.
+
+void dev_led_pwm_init()
+{
+	dlp_state = false;
+	dlp_rate = 0;
+	dlp_rateAdjust = 4;
+	
+	DEV_LED_PWM_DDR |= (1<<DEV_LED_PWM_P);			// set HIGH for output
+
+#if DEMO_BOARD == 1
+	// Extras for demo board use.
+	DDRD |= (1<<PD1);					// use Port D B1 as output
+	PORTD &= ~(1<<PD1);
+#endif
+
+	// Set up Timer 1
+	TCCR1A |= (1<<COM1A1)|(0<<COM1A0)|(0<<COM1B1)|(0<<COM1B0)|(1<<WGM11)|(1<<WGM10);	// Use OC1A pin for PWM
+	TCCR1B |= (0<<WGM13)|(1<<WGM12)|(0<<CS12)|(1<<CS11)|(1<<CS10);						// WGM = 0111 for 0x03FF as TOP..CPU div 1 = 0.050us
+	OCR1A = 0x0200;			// 50%
+	TIMSK1 |= (1<<TOIE1);					// OV bit intr
+
+	return;
+}
+
+/*
+ * Turn LED Glow OFF
+ * CMD: F0 DEV 01
+ */
+void dev_led_pwm_off()
+{
+	DEV_LED_PWM_DDR &= ~(1<<DEV_LED_PWM_P);			// set LOW for input to turn off
+	dlp_state = false;
+	return;
+}
+
+/*
+ * Turn LED Glow ON
+ * CMD: F0 DEV 02
+ */
+void dev_led_pwm_on()
+{
+	DEV_LED_PWM_DDR |= (1<<DEV_LED_PWM_P);			// set HIGH for output to turn on
+	dlp_state = true;
+	return;
+}
+
+/*
+ * Set glow rate
+ * CMD: F0 DEV 03 RATE
+ */
+void dev_led_pwm_setRate()
+{
+	dlp_rateAdjust = getMsgData(3) & 0x03FF;				// Limit to max count of Timer1
+}
+
+/*
+ * Called continuously.
+ */
+void dev_led_pwm_service()
+{
+	if( GPIOR0 & (1<<DEV_10MS_TIC) )
+	{
+		GPIOR0 &= ~(1<<DEV_10MS_TIC);
+
+		dlp_rate += dlp_rateAdjust;
+		if( dlp_rate > 0x03FF )
+			dlp_rate = 0;		
+	}
+}
+
+ISR( TIMER1_OVF_vect )
+{
+	OCR1A = dlp_rate;
+}

pool/shard010/C/0138065_mpc85xx_ads.c

@@ -0,0 +1,290 @@
+/*
+ * MPC85xx setup and early boot code plus other random bits.
+ *
+ * Maintained by Kumar Gala (see MAINTAINERS for contact information)
+ *
+ * Copyright 2005 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/kdev_t.h>
+#include <linux/delay.h>
+#include <linux/seq_file.h>
+
+#include <asm/system.h>
+#include <asm/time.h>
+#include <asm/machdep.h>
+#include <asm/pci-bridge.h>
+#include <asm/mpc85xx.h>
+#include <asm/prom.h>
+#include <asm/mpic.h>
+#include <mm/mmu_decl.h>
+#include <asm/udbg.h>
+
+#include <sysdev/fsl_soc.h>
+#include "mpc85xx.h"
+
+#ifdef CONFIG_CPM2
+#include <linux/fs_enet_pd.h>
+#include <asm/cpm2.h>
+#include <sysdev/cpm2_pic.h>
+#include <asm/fs_pd.h>
+#endif
+
+#ifndef CONFIG_PCI
+unsigned long isa_io_base = 0;
+unsigned long isa_mem_base = 0;
+#endif
+
+#ifdef CONFIG_PCI
+static int mpc85xx_exclude_device(u_char bus, u_char devfn)
+{
+	if (bus == 0 && PCI_SLOT(devfn) == 0)
+		return PCIBIOS_DEVICE_NOT_FOUND;
+	else
+		return PCIBIOS_SUCCESSFUL;
+}
+#endif /* CONFIG_PCI */
+
+#ifdef CONFIG_CPM2
+
+static void cpm2_cascade(unsigned int irq, struct irq_desc *desc)
+{
+	int cascade_irq;
+
+	while ((cascade_irq = cpm2_get_irq()) >= 0) {
+		generic_handle_irq(cascade_irq);
+	}
+	desc->chip->eoi(irq);
+}
+
+#endif /* CONFIG_CPM2 */
+
+static void __init mpc85xx_ads_pic_init(void)
+{
+	struct mpic *mpic;
+	struct resource r;
+	struct device_node *np = NULL;
+#ifdef CONFIG_CPM2
+	int irq;
+#endif
+
+	np = of_find_node_by_type(np, "open-pic");
+
+	if (np == NULL) {
+		printk(KERN_ERR "Could not find open-pic node\n");
+		return;
+	}
+
+	if(of_address_to_resource(np, 0, &r)) {
+		printk(KERN_ERR "Could not map mpic register space\n");
+		of_node_put(np);
+		return;
+	}
+
+	mpic = mpic_alloc(np, r.start,
+			MPIC_PRIMARY | MPIC_WANTS_RESET | MPIC_BIG_ENDIAN,
+			4, 0, " OpenPIC  ");
+	BUG_ON(mpic == NULL);
+	of_node_put(np);
+
+	mpic_assign_isu(mpic, 0, r.start + 0x10200);
+	mpic_assign_isu(mpic, 1, r.start + 0x10280);
+	mpic_assign_isu(mpic, 2, r.start + 0x10300);
+	mpic_assign_isu(mpic, 3, r.start + 0x10380);
+	mpic_assign_isu(mpic, 4, r.start + 0x10400);
+	mpic_assign_isu(mpic, 5, r.start + 0x10480);
+	mpic_assign_isu(mpic, 6, r.start + 0x10500);
+	mpic_assign_isu(mpic, 7, r.start + 0x10580);
+
+	/* Unused on this platform (leave room for 8548) */
+	mpic_assign_isu(mpic, 8, r.start + 0x10600);
+	mpic_assign_isu(mpic, 9, r.start + 0x10680);
+	mpic_assign_isu(mpic, 10, r.start + 0x10700);
+	mpic_assign_isu(mpic, 11, r.start + 0x10780);
+
+	/* External Interrupts */
+	mpic_assign_isu(mpic, 12, r.start + 0x10000);
+	mpic_assign_isu(mpic, 13, r.start + 0x10080);
+	mpic_assign_isu(mpic, 14, r.start + 0x10100);
+
+	mpic_init(mpic);
+
+#ifdef CONFIG_CPM2
+	/* Setup CPM2 PIC */
+	np = of_find_node_by_type(NULL, "cpm-pic");
+	if (np == NULL) {
+		printk(KERN_ERR "PIC init: can not find cpm-pic node\n");
+                return;
+	}
+	irq = irq_of_parse_and_map(np, 0);
+
+	cpm2_pic_init(np);
+	set_irq_chained_handler(irq, cpm2_cascade);
+#endif
+}
+
+/*
+ * Setup the architecture
+ */
+#ifdef CONFIG_CPM2
+void init_fcc_ioports(struct fs_platform_info *fpi)
+{
+	struct io_port *io = cpm2_map(im_ioport);
+	int fcc_no = fs_get_fcc_index(fpi->fs_no);
+	int target;
+	u32 tempval;
+
+	switch(fcc_no) {
+	case 1:
+		tempval = in_be32(&io->iop_pdirb);
+		tempval &= ~PB2_DIRB0;
+		tempval |= PB2_DIRB1;
+		out_be32(&io->iop_pdirb, tempval);
+
+		tempval = in_be32(&io->iop_psorb);
+		tempval &= ~PB2_PSORB0;
+		tempval |= PB2_PSORB1;
+		out_be32(&io->iop_psorb, tempval);
+
+		tempval = in_be32(&io->iop_pparb);
+		tempval |= (PB2_DIRB0 | PB2_DIRB1);
+		out_be32(&io->iop_pparb, tempval);
+
+		target = CPM_CLK_FCC2;
+		break;
+	case 2:
+		tempval = in_be32(&io->iop_pdirb);
+		tempval &= ~PB3_DIRB0;
+		tempval |= PB3_DIRB1;
+		out_be32(&io->iop_pdirb, tempval);
+
+		tempval = in_be32(&io->iop_psorb);
+		tempval &= ~PB3_PSORB0;
+		tempval |= PB3_PSORB1;
+		out_be32(&io->iop_psorb, tempval);
+
+		tempval = in_be32(&io->iop_pparb);
+		tempval |= (PB3_DIRB0 | PB3_DIRB1);
+		out_be32(&io->iop_pparb, tempval);
+
+		tempval = in_be32(&io->iop_pdirc);
+		tempval |= PC3_DIRC1;
+		out_be32(&io->iop_pdirc, tempval);
+
+		tempval = in_be32(&io->iop_pparc);
+		tempval |= PC3_DIRC1;
+		out_be32(&io->iop_pparc, tempval);
+
+		target = CPM_CLK_FCC3;
+		break;
+	default:
+		printk(KERN_ERR "init_fcc_ioports: invalid FCC number\n");
+		return;
+	}
+
+	/* Port C has clocks......  */
+	tempval = in_be32(&io->iop_psorc);
+	tempval &= ~(PC_CLK(fpi->clk_rx - 8) | PC_CLK(fpi->clk_tx - 8));
+	out_be32(&io->iop_psorc, tempval);
+
+	tempval = in_be32(&io->iop_pdirc);
+	tempval &= ~(PC_CLK(fpi->clk_rx - 8) | PC_CLK(fpi->clk_tx - 8));
+	out_be32(&io->iop_pdirc, tempval);
+	tempval = in_be32(&io->iop_pparc);
+	tempval |= (PC_CLK(fpi->clk_rx - 8) | PC_CLK(fpi->clk_tx - 8));
+	out_be32(&io->iop_pparc, tempval);
+
+	cpm2_unmap(io);
+
+	/* Configure Serial Interface clock routing.
+	 * First,  clear FCC bits to zero,
+	 * then set the ones we want.
+	 */
+	cpm2_clk_setup(target, fpi->clk_rx, CPM_CLK_RX);
+	cpm2_clk_setup(target, fpi->clk_tx, CPM_CLK_TX);
+}
+#endif
+
+static void __init mpc85xx_ads_setup_arch(void)
+{
+	struct device_node *cpu;
+#ifdef CONFIG_PCI
+	struct device_node *np;
+#endif
+
+	if (ppc_md.progress)
+		ppc_md.progress("mpc85xx_ads_setup_arch()", 0);
+
+	cpu = of_find_node_by_type(NULL, "cpu");
+	if (cpu != 0) {
+		const unsigned int *fp;
+
+		fp = get_property(cpu, "clock-frequency", NULL);
+		if (fp != 0)
+			loops_per_jiffy = *fp / HZ;
+		else
+			loops_per_jiffy = 50000000 / HZ;
+		of_node_put(cpu);
+	}
+
+#ifdef CONFIG_CPM2
+	cpm2_reset();
+#endif
+
+#ifdef CONFIG_PCI
+	for (np = NULL; (np = of_find_node_by_type(np, "pci")) != NULL;)
+		add_bridge(np);
+	ppc_md.pci_exclude_device = mpc85xx_exclude_device;
+#endif
+}
+
+static void mpc85xx_ads_show_cpuinfo(struct seq_file *m)
+{
+	uint pvid, svid, phid1;
+	uint memsize = total_memory;
+
+	pvid = mfspr(SPRN_PVR);
+	svid = mfspr(SPRN_SVR);
+
+	seq_printf(m, "Vendor\t\t: Freescale Semiconductor\n");
+	seq_printf(m, "Machine\t\t: mpc85xx\n");
+	seq_printf(m, "PVR\t\t: 0x%x\n", pvid);
+	seq_printf(m, "SVR\t\t: 0x%x\n", svid);
+
+	/* Display cpu Pll setting */
+	phid1 = mfspr(SPRN_HID1);
+	seq_printf(m, "PLL setting\t: 0x%x\n", ((phid1 >> 24) & 0x3f));
+
+	/* Display the amount of memory */
+	seq_printf(m, "Memory\t\t: %d MB\n", memsize / (1024 * 1024));
+}
+
+/*
+ * Called very early, device-tree isn't unflattened
+ */
+static int __init mpc85xx_ads_probe(void)
+{
+        unsigned long root = of_get_flat_dt_root();
+
+        return of_flat_dt_is_compatible(root, "MPC85xxADS");
+}
+
+define_machine(mpc85xx_ads) {
+	.name			= "MPC85xx ADS",
+	.probe			= mpc85xx_ads_probe,
+	.setup_arch		= mpc85xx_ads_setup_arch,
+	.init_IRQ		= mpc85xx_ads_pic_init,
+	.show_cpuinfo		= mpc85xx_ads_show_cpuinfo,
+	.get_irq		= mpic_get_irq,
+	.restart		= mpc85xx_restart,
+	.calibrate_decr		= generic_calibrate_decr,
+	.progress		= udbg_progress,
+};

pool/shard010/C/0138066_gnu_java_awt_peer_gtk_GtkClipboard.c

@@ -0,0 +1,183 @@
+/* gtkclipboard.c
+   Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+#include "gtkpeer.h"
+#include "gnu_java_awt_peer_gtk_GtkClipboard.h"
+
+jmethodID stringSelectionReceivedID;
+jmethodID stringSelectionHandlerID;
+jmethodID selectionClearID;
+
+void selection_received (GtkWidget *, GtkSelectionData *, guint, gpointer);
+void selection_get (GtkWidget *, GtkSelectionData *, guint, guint, gpointer);
+gint selection_clear (GtkWidget *, GdkEventSelection *);
+
+GtkWidget *clipboard;
+jobject cb_obj;
+
+JNIEXPORT void JNICALL 
+Java_gnu_java_awt_peer_gtk_GtkClipboard_initNativeState (JNIEnv *env, 
+							 jobject obj)
+{
+  if (!stringSelectionReceivedID)
+    {
+      jclass gtkclipboard;
+
+      gtkclipboard = (*env)->FindClass (env, 
+					"gnu/java/awt/peer/gtk/GtkClipboard");
+      stringSelectionReceivedID = (*env)->GetMethodID (env, gtkclipboard,
+						    "stringSelectionReceived",
+						    "(Ljava/lang/String;)V");
+      stringSelectionHandlerID = (*env)->GetMethodID (env, gtkclipboard,
+						      "stringSelectionHandler",
+						      "()Ljava/lang/String;");
+      selectionClearID = (*env)->GetMethodID (env, gtkclipboard,
+					      "selectionClear", "()V");
+    }
+
+  cb_obj = (*env)->NewGlobalRef (env, obj);
+
+  gdk_threads_enter ();
+  clipboard = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+  g_signal_connect (G_OBJECT(clipboard), "selection_received",
+		      GTK_SIGNAL_FUNC (selection_received), NULL);
+
+  g_signal_connect (G_OBJECT(clipboard), "selection_clear_event",
+		      GTK_SIGNAL_FUNC (selection_clear), NULL);
+
+  gtk_selection_add_target (clipboard, GDK_SELECTION_PRIMARY, 
+			    GDK_TARGET_STRING, 0);
+
+  g_signal_connect (G_OBJECT(clipboard), "selection_get",
+                      GTK_SIGNAL_FUNC (selection_get), NULL);
+
+  gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkClipboard_requestStringConversion
+  (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)))
+{
+  gdk_threads_enter ();
+  gtk_selection_convert (clipboard, GDK_SELECTION_PRIMARY, 
+			 GDK_TARGET_STRING, GDK_CURRENT_TIME);
+  gdk_threads_leave ();
+}
+
+void
+selection_received (GtkWidget *widget __attribute__((unused)),
+		    GtkSelectionData *selection_data __attribute__((unused)),
+		    guint time __attribute__((unused)),
+		    gpointer data __attribute__((unused)))
+{
+  /* Check to see if retrieval succeeded  */
+  if (selection_data->length < 0
+      || selection_data->type != GDK_SELECTION_TYPE_STRING)
+    {
+      (*gdk_env())->CallVoidMethod (gdk_env(), cb_obj, stringSelectionReceivedID,
+				    NULL);
+    }
+  else
+    {
+      char *str = (char *) selection_data->data;
+      
+      (*gdk_env())->CallVoidMethod (gdk_env(), cb_obj, stringSelectionReceivedID,
+				    (*gdk_env())->NewStringUTF (gdk_env(), str));
+    }
+
+  return;
+}
+
+void
+selection_get (GtkWidget *widget __attribute__((unused)), 
+               GtkSelectionData *selection_data,
+               guint      info __attribute__((unused)),
+               guint      time __attribute__((unused)),
+               gpointer   data __attribute__((unused)))
+{
+  jstring jstr;
+  const char *utf;
+  jsize utflen;
+
+  jstr = (*gdk_env())->CallObjectMethod (gdk_env(), cb_obj, 
+				       stringSelectionHandlerID);
+
+  if (!jstr)
+    {
+      gtk_selection_data_set (selection_data, 
+			      GDK_TARGET_STRING, 8, NULL, 0);
+      return;
+    }
+
+  utflen = (*gdk_env())->GetStringUTFLength (gdk_env(), jstr);
+  utf = (*gdk_env())->GetStringUTFChars (gdk_env(), jstr, NULL);
+
+  gtk_selection_data_set (selection_data, GDK_TARGET_STRING, 8,
+			  (const unsigned char*)utf, utflen);
+
+  (*gdk_env())->ReleaseStringUTFChars (gdk_env(), jstr, utf);
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkClipboard_selectionGet
+  (JNIEnv *env, jclass clazz __attribute__((unused)))
+{
+  GdkWindow *owner;
+
+  gdk_threads_enter ();
+
+  /* if we already own the clipboard, we need to tell the old data object
+     that we're no longer going to be using him */
+  owner = gdk_selection_owner_get (GDK_SELECTION_PRIMARY);
+  if (owner && owner == clipboard->window)
+    (*env)->CallVoidMethod (env, cb_obj, selectionClearID);
+    
+  gtk_selection_owner_set (clipboard, GDK_SELECTION_PRIMARY, GDK_CURRENT_TIME);
+
+  gdk_threads_leave ();
+}
+
+gint
+selection_clear (GtkWidget *widget __attribute__((unused)),
+		 GdkEventSelection *event __attribute__((unused)))
+{
+  (*gdk_env())->CallVoidMethod (gdk_env(), cb_obj, selectionClearID);
+
+  return TRUE;
+}

pool/shard010/C/0138067_string.c

@@ -0,0 +1,277 @@
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <assert.h>
+#include "util/memory.h"
+#include "util/string.h"
+
+/* ----------------------------------------------------------------------------
+ * Static functions
+ * ------------------------------------------------------------------------- */
+static uintptr_t
+safe_strlen(const char* str)
+{
+	if(str)
+		return strlen(str);
+	return 0;
+}
+
+/* ------------------------------------------------------------------------- */
+static void
+safe_strcat(char* target, const char* source)
+{
+	assert(target);
+	if(source)
+		strcat(target, source);
+}
+
+/* ------------------------------------------------------------------------- */
+static uintptr_t
+safe_wcslen(const wchar_t* wcs)
+{
+	if(wcs)
+		return wcslen(wcs);
+	return 0;
+}
+
+/* ------------------------------------------------------------------------- */
+static void
+safe_wcscat(wchar_t* target, const wchar_t* source)
+{
+	assert(target);
+	if(source)
+		wcscat(target, source);
+}
+
+/* ----------------------------------------------------------------------------
+ * Exported functions
+ * ------------------------------------------------------------------------- */
+void
+free_string(void* ptr)
+{
+	assert(ptr);
+	FREE(ptr);
+}
+
+/* ------------------------------------------------------------------------- */
+char*
+cat_strings(uint32_t num_strs, ...)
+{
+	uint32_t total_length = 0;
+	uint32_t i;
+	char* buffer;
+	va_list ap;
+
+	/* compute total length of all strings combined and allocate a buffer able
+	 * to contain all strings plus a null terminator */
+	va_start(ap, num_strs);
+	for(i = 0; i != num_strs; ++i)
+		total_length += safe_strlen(va_arg(ap, char*));
+	va_end(ap);
+
+	buffer = (char*)MALLOC((total_length+1) * sizeof(char));
+	if(!buffer)
+	{
+		fprintf(stderr, "malloc() failed in cat_strings() -- not enough memory\n");
+		return NULL;
+	}
+	*buffer = '\0'; /* so strcat works */
+
+	/* concatenate all strings into the allocated buffer */
+	va_start(ap, num_strs);
+	for(i = 0; i != num_strs; ++i)
+		safe_strcat(buffer, va_arg(ap, char*));
+	va_end(ap);
+
+	return buffer;
+}
+
+/* ------------------------------------------------------------------------- */
+char*
+malloc_string(const char* str)
+{
+	char* buffer;
+	assert(str);
+
+	buffer = (char*)MALLOC((strlen(str)+1) * sizeof(char));
+	if(!buffer)
+	{
+		fprintf(stderr, "malloc() failed in malloc_string() -- not enough memory\n");
+		return NULL;
+	}
+
+	strcpy(buffer, str);
+	return buffer;
+}
+
+/* ------------------------------------------------------------------------- */
+wchar_t*
+cat_wstrings(uint32_t num_strs, ...)
+{
+	uint32_t total_length = 0;
+	uint32_t i;
+	wchar_t* buffer;
+	va_list ap;
+
+	/* compute total length of all strings combined and allocate a buffer able
+	 * to contain all strings plus a null terminator */
+	va_start(ap, num_strs);
+	for(i = 0; i != num_strs; ++i)
+		total_length += safe_wcslen(va_arg(ap, wchar_t*));
+	va_end(ap);
+
+	buffer = (wchar_t*)MALLOC((total_length+1) * sizeof(wchar_t));
+	if(!buffer)
+	{
+		fprintf(stderr, "malloc() failed in cat_wstrings() -- not enough memory\n");
+		return NULL;
+	}
+	*buffer = L'\0'; /* so wcscat works */
+
+	/* concatenate all strings into the allocated buffer */
+	va_start(ap, num_strs);
+	for(i = 0; i != num_strs; ++i)
+		safe_wcscat(buffer, va_arg(ap, wchar_t*));
+	va_end(ap);
+
+	return buffer;
+}
+
+/* ------------------------------------------------------------------------- */
+wchar_t*
+malloc_wstring(const wchar_t* wcs)
+{
+	wchar_t* buffer;
+	assert(wcs);
+
+	buffer = (wchar_t*)MALLOC((wcslen(wcs)+1) * sizeof(wchar_t));
+	if(!buffer)
+	{
+		fprintf(stderr, "malloc() failed in malloc_wstring() -- not enough memory\n");
+		return NULL;
+	}
+
+	wcscpy(buffer, wcs);
+	return buffer;
+}
+
+/* ------------------------------------------------------------------------- */
+char*
+strtok_r_portable(char* str, char delimiter, char** saveptr)
+{
+	char* begin_ptr;
+	char* end_ptr;
+
+	if(str)
+		*saveptr = str - 1;
+
+	/* no more tokens */
+	if(!*saveptr)
+		return NULL;
+
+	/* get first occurrence of token in string */
+	begin_ptr = *saveptr + 1;
+	end_ptr = (char*)strchr(begin_ptr, delimiter);
+	if(!end_ptr)
+		*saveptr = NULL; /* last token has been reached */
+	else
+	{
+		/* update saveptr and replace delimiter with null terminator */
+		*saveptr = end_ptr;
+		**saveptr = '\0';
+	}
+
+	/* empty tokens */
+	if(*begin_ptr == '\0')
+		return NULL;
+	return begin_ptr;
+}
+
+/* ------------------------------------------------------------------------- */
+wchar_t*
+strtowcs(const char* str)
+{
+	wchar_t* wcs;
+	wchar_t* wcs_it;
+	uintptr_t len;
+
+	assert(str);
+
+	len = strlen(str);
+
+	wcs = (wchar_t*)MALLOC((len + 1) * sizeof(wchar_t));
+	if(!wcs)
+	{
+		fprintf(stderr, "malloc() failed in strtowcs() -- not enough memory\n");
+		return NULL;
+	}
+
+	for(wcs_it = wcs; *str; ++str)
+		*wcs_it++ = (wchar_t)*str;
+	*wcs_it = L'\0';
+	return wcs;
+}
+
+/* ------------------------------------------------------------------------- */
+char*
+wcstostr(const wchar_t* wcs)
+{
+	char* str;
+	char* str_it;
+	uintptr_t len;
+
+	assert(wcs);
+
+	len = wcslen(wcs);
+
+	str = (char*)MALLOC((len + 1) * sizeof(char));
+	if(!str)
+	{
+		fprintf(stderr, "malloc() failed in wcstostr() -- not enough memory\n");
+		return NULL;
+	}
+
+	for(str_it = str; *wcs; ++wcs)
+		*str_it++ = (char)*wcs;
+	*str_it = '\0';
+	return str;
+}
+
+/* ------------------------------------------------------------------------- */
+void
+crlf2lf(char* src)
+{
+	char* target;
+
+	assert(src);
+
+	target = src;
+	while(*src)
+	{
+		if(*src == '\r') /* skip any CRs */
+			++src;
+		*target++ = *src++;
+	}
+
+	/* if at least one CR was skipped, a new null-terminator must be set. */
+	if(target != src)
+		*target = '\0';
+}
+
+/* ------------------------------------------------------------------------- */
+void
+string_reverse(char* str)
+{
+	char* end;
+
+	assert(str);
+
+	end = str + strlen(str) - 1;
+	for(; str < end; ++str, --end)
+	{
+		char tmp = *str;
+		*str = *end;
+		*end = tmp;
+	}
+}

pool/shard010/C/0138068_getValidInteger.c

@@ -0,0 +1,103 @@
+/*
+ * Filename:    getValidInteger.c
+ * Author:      Andrew Laing
+ * Email:       parisianconnections@gmail.com
+ * Date:        19/08/2017.
+ * Description: Input an Integer
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#define MAXLEN 9
+
+int getLine( char [], int );
+int isValidIntegerString( const char * );
+int getValidInteger();
+
+
+int main()
+{
+    int num1;
+    
+    printf("Enter integer string > ");
+    num1 = getValidInteger();
+    
+    printf("num1 = %d\n", num1);
+         
+    return 0;
+}
+
+
+/* Read a string into a character array and return the length of the array  
+ * Note: this produces an error message if the user trys to overflow the
+ *       the character array, but allows them to retype rather than crashing
+ */
+int getLine( char s[], int maxLength )
+{
+    int c, count, i, validLine=0;
+    
+    while(validLine == 0)
+    {
+        count=0, i=0;
+        while( count <= maxLength && ( (c=getchar())!=EOF ) && ( c!='\n' ) )
+        {
+            s[i++]=c;
+            count++;
+        }
+        
+        if( count > maxLength ) {
+            printf("Error - max line length is %d characters\n", maxLength );
+            printf("Please retype line: ");
+        }
+        else validLine++;   
+    
+        fflush(stdin);  /* Clear any overflow*/
+    }
+
+    if(c=='\n')
+        s[i++]=c;
+    s[i] = '\0';
+
+    
+    fflush(stdin);  /* Clear any overflow*/
+    
+    return i;   
+}
+
+
+
+/* This method gets the user to input, then returns a valid integer
+ * Note: The maximum length of the integer is define as MAXLEN, and 
+ *       at the moment the method does not check that the string
+ *       is within system integer boundaries. 
+ 
+ ** PROBLEM CAUSED BY SSCANF skipping SPACES
+ */
+int getValidInteger()
+{
+    char str[MAXLEN+1];
+    int result = 0;
+    int validInt = 0;
+    
+    /* Input a string */
+    getLine(str, MAXLEN);
+    
+    /* If the string is valid convert and return it */
+    while(validInt == 0)
+    { 
+        /* sscanf returns the number of conversions made */
+        if( !isspace(str[0]) )
+            validInt = sscanf(str, "%d", &result); 
+
+        if( validInt == 0 ) 
+        {
+            printf("Error - Please enter a valid number: ");
+            getLine(str, MAXLEN);           
+        }
+    }
+
+    return result;
+}
+

pool/shard010/C/0138069_H5Tdeprec.c

@@ -0,0 +1,205 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the COPYING file, which can be found at the root of the source code       *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.  *
+ * If you do not have access to either file, you may request a copy from     *
+ * help@hdfgroup.org.                                                        *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*-------------------------------------------------------------------------
+ *
+ * Created:	H5Tdeprec.c
+ *		April 5 2007
+ *		Quincey Koziol <koziol@hdfgroup.org>
+ *
+ * Purpose:	Deprecated functions from the H5T interface.  These
+ *              functions are here for compatibility purposes and may be
+ *              removed in the future.  Applications should switch to the
+ *              newer APIs.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/****************/
+/* Module Setup */
+/****************/
+
+#include "H5Tmodule.h"          /* This source code file is part of the H5T module */
+
+
+/***********/
+/* Headers */
+/***********/
+#include "H5private.h"		/* Generic Functions			*/
+#include "H5ACprivate.h"        /* Metadata cache                       */
+#include "H5Eprivate.h"		/* Error handling		  	*/
+#include "H5FOprivate.h"	/* File objects				*/
+#include "H5Iprivate.h"		/* IDs					*/
+#include "H5Ppublic.h"		/* Property Lists			*/
+#include "H5Tpkg.h"		/* Datatypes				*/
+
+
+/****************/
+/* Local Macros */
+/****************/
+
+
+/******************/
+/* Local Typedefs */
+/******************/
+
+
+/********************/
+/* Package Typedefs */
+/********************/
+
+
+/********************/
+/* Local Prototypes */
+/********************/
+
+
+/*********************/
+/* Package Variables */
+/*********************/
+
+
+/*****************************/
+/* Library Private Variables */
+/*****************************/
+
+
+/*******************/
+/* Local Variables */
+/*******************/
+
+
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Tcommit1
+ *
+ * Purpose:	Save a transient datatype to a file and turn the type handle
+ *		into a named, immutable type.
+ *
+ * Note:	Deprecated in favor of H5Tcommit2
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Robb Matzke
+ *              Monday, June  1, 1998
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Tcommit1(hid_t loc_id, const char *name, hid_t type_id)
+{
+    H5G_loc_t	loc;                    /* Location to create datatype */
+    H5T_t	*type;                  /* Datatype for ID */
+    herr_t      ret_value = SUCCEED;    /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE3("e", "i*si", loc_id, name, type_id);
+
+    /* Check arguments */
+    if(H5G_loc(loc_id, &loc) < 0)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
+    if(!name || !*name)
+	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
+    if(NULL == (type = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
+	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+
+    /* Commit the datatype to the file, using default property list values */
+    if(H5T__commit_named(&loc, name, type, H5P_LINK_CREATE_DEFAULT,
+            H5P_DATATYPE_CREATE_DEFAULT, H5P_DATATYPE_ACCESS_DEFAULT, H5AC_ind_read_dxpl_id) < 0)
+	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to commit datatype")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Tcommit1() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Topen1
+ *
+ * Purpose:	Opens a named datatype.
+ *
+ * Note:	Deprecated in favor of H5Topen2
+ *
+ * Return:	Success:	Object ID of the named datatype.
+ *
+ *		Failure:	Negative
+ *
+ * Programmer:	Robb Matzke
+ *              Monday, June  1, 1998
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Topen1(hid_t loc_id, const char *name)
+{
+    H5T_t       *type = NULL;
+    H5G_loc_t	 loc;
+    H5G_name_t   path;            	/* Datatype group hier. path */
+    H5O_loc_t    oloc;            	/* Datatype object location */
+    H5O_type_t   obj_type;              /* Type of object at location */
+    H5G_loc_t    type_loc;              /* Group object for datatype */
+    hbool_t      obj_found = FALSE;     /* Object at 'name' found */
+    hid_t        dxpl_id = H5AC_ind_read_dxpl_id; /* dxpl to use to open datatype */
+    hid_t        ret_value = FAIL;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("i", "i*s", loc_id, name);
+
+    /* Check args */
+    if(H5G_loc(loc_id, &loc) < 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location")
+    if(!name || !*name)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
+
+    /* Set up datatype location to fill in */
+    type_loc.oloc = &oloc;
+    type_loc.path = &path;
+    H5G_loc_reset(&type_loc);
+
+    /*
+     * Find the named datatype object header and read the datatype message
+     * from it.
+     */
+    if(H5G_loc_find(&loc, name, &type_loc/*out*/, H5P_DEFAULT, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_NOTFOUND, FAIL, "not found")
+    obj_found = TRUE;
+
+    /* Check that the object found is the correct type */
+    if(H5O_obj_type(&oloc, &obj_type, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, FAIL, "can't get object type")
+    if(obj_type != H5O_TYPE_NAMED_DATATYPE)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "not a named datatype")
+
+    /* Open it */
+    if((type = H5T_open(&type_loc, dxpl_id)) == NULL)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTOPENOBJ, FAIL, "unable to open named datatype")
+
+    /* Register the type and return the ID */
+    if((ret_value = H5I_register(H5I_DATATYPE, type, TRUE)) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register named datatype")
+
+done:
+    if(ret_value < 0) {
+        if(type != NULL)
+            H5T_close(type);
+        else {
+            if(obj_found && H5F_addr_defined(type_loc.oloc->addr))
+                H5G_loc_free(&type_loc);
+        } /* end else */
+    } /* end if */
+
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Topen1() */
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
+

pool/shard010/C/0138070_syscall.c

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+ * Licensed under the GPL
+ */
+
+#include "linux/file.h"
+#include "linux/fs.h"
+#include "linux/mm.h"
+#include "linux/sched.h"
+#include "linux/utsname.h"
+#include "linux/syscalls.h"
+#include "asm/current.h"
+#include "asm/mman.h"
+#include "asm/uaccess.h"
+#include "asm/unistd.h"
+#include "internal.h"
+
+long sys_fork(void)
+{
+	return do_fork(SIGCHLD, UPT_SP(&current->thread.regs.regs),
+		      &current->thread.regs, 0, NULL, NULL);
+}
+
+long sys_vfork(void)
+{
+	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
+		      UPT_SP(&current->thread.regs.regs),
+		      &current->thread.regs, 0, NULL, NULL);
+}
+
+long sys_clone(unsigned long clone_flags, unsigned long newsp,
+	       void __user *parent_tid, void __user *child_tid)
+{
+	if (!newsp)
+		newsp = UPT_SP(&current->thread.regs.regs);
+
+	return do_fork(clone_flags, newsp, &current->thread.regs, 0, parent_tid,
+		      child_tid);
+}
+
+long old_mmap(unsigned long addr, unsigned long len,
+	      unsigned long prot, unsigned long flags,
+	      unsigned long fd, unsigned long offset)
+{
+	long err = -EINVAL;
+	if (offset & ~PAGE_MASK)
+		goto out;
+
+	err = sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
+ out:
+	return err;
+}
+
+int kernel_execve(const char *filename,
+		  const char *const argv[],
+		  const char *const envp[])
+{
+	mm_segment_t fs;
+	int ret;
+
+	fs = get_fs();
+	set_fs(KERNEL_DS);
+	ret = um_execve(filename, (const char __user *const __user *)argv,
+			(const char __user *const __user *) envp);
+	set_fs(fs);
+
+	return ret;
+}

pool/shard010/C/0138071_alert.c

@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) Tildeslash Ltd. All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ *
+ * You must obey the GNU Affero General Public License in all respects
+ * for all of the code used other than OpenSSL.
+ */
+
+#include "config.h"
+
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+
+#include "monit.h"
+#include "event.h"
+#include "net.h"
+#include "alert.h"
+
+// libmonit
+#include "system/Time.h"
+#include "util/Str.h"
+
+
+/**
+ *  Implementation of the alert module
+ *
+ *  @file
+ */
+
+
+/* -------------------------------------------------------------- Prototypes */
+
+
+static void copy_mail(Mail_T, Mail_T);
+static void escape(Mail_T);
+static void substitute(Mail_T, Event_T);
+
+
+/* ------------------------------------------------------------------ Public */
+
+
+/**
+ * Notify registred users about the event
+ * @param E An Event object
+ * @return If failed, return Handler_Alert flag or Handler_Succeeded if succeeded
+ */
+Handler_Type handle_alert(Event_T E) {
+        Handler_Type rv = Handler_Succeeded;
+
+        ASSERT(E);
+
+        Service_T s = Event_get_source(E);
+        if (! s) {
+                LogError("Aborting alert\n");
+                return rv;
+        }
+        if (s->maillist || Run.maillist) {
+                Mail_T list = NULL;
+                /*
+                 * Build a mail-list with local recipients that has registered interest
+                 * for this event.
+                 */
+                for (Mail_T m = s->maillist; m; m = m->next) {
+                        if (
+                            /* particular event notification type is allowed for given recipient */
+                            IS_EVENT_SET(m->events, Event_get_id(E)) &&
+                            (
+                             /* state change notification is sent always */
+                             E->state_changed       ||
+                             /* in the case that the state is failed for more cycles we check
+                              * whether we should send the reminder */
+                             (E->state && m->reminder && E->count % m->reminder == 0)
+                             )
+                            )
+                        {
+                                Mail_T tmp = NULL;
+                                NEW(tmp);
+                                copy_mail(tmp, m);
+                                substitute(tmp, E);
+                                escape(tmp);
+                                tmp->next = list;
+                                list = tmp;
+                                DEBUG("%s notification is sent to %s\n", Event_get_description(E), m->to);
+                        }
+                }
+                /*
+                 * Build a mail-list with global recipients that has registered interest
+                 * for this event. Recipients which are defined in the service localy
+                 * overrides the same recipient events which are registered globaly.
+                 */
+                for (Mail_T m = Run.maillist; m; m = m->next) {
+                        boolean_t skip = false;
+                        for (Mail_T n = s->maillist; n; n = n->next) {
+                                if (IS(m->to, n->to)) {
+                                        skip = true;
+                                        break;
+                                }
+                        }
+                        if (
+                            /* the local service alert definition has not overrided the global one */
+                            ! skip &&
+                            /* particular event notification type is allowed for given recipient */
+                            IS_EVENT_SET(m->events, Event_get_id(E)) &&
+                            (
+                             /* state change notification is sent always */
+                             E->state_changed       ||
+                             /* in the case that the state is failed for more cycles we check
+                              * whether we should send the reminder */
+                             (E->state && m->reminder && E->count % m->reminder == 0)
+                             )
+                            )
+                        {
+                                Mail_T tmp = NULL;
+                                NEW(tmp);
+                                copy_mail(tmp, m);
+                                substitute(tmp, E);
+                                escape(tmp);
+                                tmp->next = list;
+                                list = tmp;
+                                DEBUG("%s notification is sent to %s\n", Event_get_description(E), m->to);
+                        }
+                }
+                if (list) {
+                        if (sendmail(list))
+                                rv = Handler_Alert;
+                        gc_mail_list(&list);
+                }
+        }
+        return rv;
+}
+
+
+static void substitute(Mail_T m, Event_T e) {
+        char timestamp[STRLEN];
+
+        ASSERT(m && e);
+
+        Util_replaceString(&m->from,    "$HOST", Run.system->name);
+        Util_replaceString(&m->subject, "$HOST", Run.system->name);
+        Util_replaceString(&m->message, "$HOST", Run.system->name);
+
+        Time_string(e->collected.tv_sec, timestamp);
+        Util_replaceString(&m->subject, "$DATE", timestamp);
+        Util_replaceString(&m->message, "$DATE", timestamp);
+
+        Util_replaceString(&m->subject, "$SERVICE", Event_get_source_name(e));
+        Util_replaceString(&m->message, "$SERVICE", Event_get_source_name(e));
+
+        Util_replaceString(&m->subject, "$EVENT", Event_get_description(e));
+        Util_replaceString(&m->message, "$EVENT", Event_get_description(e));
+
+        Util_replaceString(&m->subject, "$DESCRIPTION", NVLSTR(Event_get_message(e)));
+        Util_replaceString(&m->message, "$DESCRIPTION", NVLSTR(Event_get_message(e)));
+
+        Util_replaceString(&m->subject, "$ACTION", Event_get_action_description(e));
+        Util_replaceString(&m->message, "$ACTION", Event_get_action_description(e));
+}
+
+
+static void copy_mail(Mail_T n, Mail_T o) {
+        ASSERT(n && o);
+
+        n->to = Str_dup(o->to);
+        n->from = o->from ? Str_dup(o->from) : Run.MailFormat.from ? Str_dup(Run.MailFormat.from) : Str_dup(ALERT_FROM);
+        n->replyto = o->replyto ? Str_dup(o->replyto) : Run.MailFormat.replyto ? Str_dup(Run.MailFormat.replyto) : NULL;
+        n->subject = o->subject ? Str_dup(o->subject) : Run.MailFormat.subject ? Str_dup(Run.MailFormat.subject) : Str_dup(ALERT_SUBJECT);
+        n->message = o->message ? Str_dup(o->message) : Run.MailFormat.message ? Str_dup(Run.MailFormat.message) : Str_dup(ALERT_MESSAGE);
+}
+
+
+static void escape(Mail_T m) {
+        // replace bare linefeed
+        Util_replaceString(&m->message, "\r\n", "\n");
+        Util_replaceString(&m->message, "\n", "\r\n");
+        // escape ^.
+        Util_replaceString(&m->message, "\n.", "\n..");
+        // drop any CR|LF from the subject
+        Str_chomp(m->subject);
+}
+

pool/shard010/C/0138072_tty.c

@@ -0,0 +1,86 @@
+/* 
+ * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include "chan_user.h"
+#include "user_util.h"
+#include "user.h"
+#include "os.h"
+
+struct tty_chan {
+	char *dev;
+	int raw;
+	struct termios tt;
+};
+
+void *tty_chan_init(char *str, int device, struct chan_opts *opts)
+{
+	struct tty_chan *data;
+
+	if(*str != ':'){
+		printk("tty_init : channel type 'tty' must specify "
+		       "a device\n");
+		return(NULL);
+	}
+	str++;
+
+	if((data = um_kmalloc(sizeof(*data))) == NULL) 
+		return(NULL);
+	*data = ((struct tty_chan) { .dev 	= str,
+				     .raw 	= opts->raw });
+				     
+	return(data);
+}
+
+int tty_open(int input, int output, int primary, void *d, char **dev_out)
+{
+	struct tty_chan *data = d;
+	int fd;
+
+	fd = os_open_file(data->dev, of_set_rw(OPENFLAGS(), input, output), 0);
+	if(fd < 0) return(fd);
+	if(data->raw){
+		tcgetattr(fd, &data->tt);
+		raw(fd, 0);
+	}
+
+	*dev_out = data->dev;
+	return(fd);
+}
+
+int tty_console_write(int fd, const char *buf, int n, void *d)
+{
+	struct tty_chan *data = d;
+
+	return(generic_console_write(fd, buf, n, &data->tt));
+}
+
+struct chan_ops tty_ops = {
+	.type		= "tty",
+	.init		= tty_chan_init,
+	.open		= tty_open,
+	.close		= generic_close,
+	.read		= generic_read,
+	.write		= generic_write,
+	.console_write	= tty_console_write,
+	.window_size	= generic_window_size,
+	.free		= generic_free,
+	.winch		= 0,
+};
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

pool/shard010/C/0138073_igep0020.c

@@ -0,0 +1,137 @@
+/*
+ * (C) Copyright 2010
+ * ISEE 2007 SL, <www.iseebcn.com>
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+#include <common.h>
+#include <netdev.h>
+#include <twl4030.h>
+#include <asm/io.h>
+#include <asm/gpio.h>
+#include <asm/arch/mem.h>
+#include <asm/arch/mmc_host_def.h>
+#include <asm/arch/mux.h>
+#include <asm/arch/sys_proto.h>
+#include <asm/arch/omap_gpmc.h>
+#include <asm/mach-types.h>
+#include "igep0020.h"
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/* GPMC definitions for LAN9221 chips */
+static const u32 gpmc_lan_config[] = {
+    NET_LAN9221_GPMC_CONFIG1,
+    NET_LAN9221_GPMC_CONFIG2,
+    NET_LAN9221_GPMC_CONFIG3,
+    NET_LAN9221_GPMC_CONFIG4,
+    NET_LAN9221_GPMC_CONFIG5,
+    NET_LAN9221_GPMC_CONFIG6,
+};
+
+/*
+ * Routine: board_init
+ * Description: Early hardware init.
+ */
+int board_init(void)
+{
+	gpmc_init(); /* in SRAM or SDRAM, finish GPMC */
+	/* boot param addr */
+	gd->bd->bi_boot_params = (OMAP34XX_SDRC_CS0 + 0x100);
+
+	return 0;
+}
+
+/*
+ * Routine: setup_net_chip
+ * Description: Setting up the configuration GPMC registers specific to the
+ *		Ethernet hardware.
+ */
+#if defined(CONFIG_CMD_NET)
+static void setup_net_chip(void)
+{
+	struct ctrl *ctrl_base = (struct ctrl *)OMAP34XX_CTRL_BASE;
+
+	enable_gpmc_cs_config(gpmc_lan_config, &gpmc_cfg->cs[5], 0x2C000000,
+			GPMC_SIZE_16M);
+
+	/* Enable off mode for NWE in PADCONF_GPMC_NWE register */
+	writew(readw(&ctrl_base->gpmc_nwe) | 0x0E00, &ctrl_base->gpmc_nwe);
+	/* Enable off mode for NOE in PADCONF_GPMC_NADV_ALE register */
+	writew(readw(&ctrl_base->gpmc_noe) | 0x0E00, &ctrl_base->gpmc_noe);
+	/* Enable off mode for ALE in PADCONF_GPMC_NADV_ALE register */
+	writew(readw(&ctrl_base->gpmc_nadv_ale) | 0x0E00,
+		&ctrl_base->gpmc_nadv_ale);
+
+	/* Make GPIO 64 as output pin and send a magic pulse through it */
+	if (!gpio_request(64, "")) {
+		gpio_direction_output(64, 0);
+		gpio_set_value(64, 1);
+		udelay(1);
+		gpio_set_value(64, 0);
+		udelay(1);
+		gpio_set_value(64, 1);
+	}
+}
+#endif
+
+#ifdef CONFIG_GENERIC_MMC
+int board_mmc_init(bd_t *bis)
+{
+	omap_mmc_init(0, 0, 0);
+	return 0;
+}
+#endif
+
+/*
+ * Routine: misc_init_r
+ * Description: Configure board specific parts
+ */
+int misc_init_r(void)
+{
+	twl4030_power_init();
+
+#if defined(CONFIG_CMD_NET)
+	setup_net_chip();
+#endif
+
+	dieid_num_r();
+
+	return 0;
+}
+
+/*
+ * Routine: set_muxconf_regs
+ * Description: Setting up the configuration Mux registers specific to the
+ *		hardware. Many pins need to be moved from protect to primary
+ *		mode.
+ */
+void set_muxconf_regs(void)
+{
+	MUX_DEFAULT();
+}
+
+int board_eth_init(bd_t *bis)
+{
+	int rc = 0;
+#ifdef CONFIG_SMC911X
+	rc = smc911x_initialize(0, CONFIG_SMC911X_BASE);
+#endif
+	return rc;
+}

pool/shard010/C/0138074_machvec.c

@@ -0,0 +1,70 @@
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <asm/machvec.h>
+#include <asm/system.h>
+
+#ifdef CONFIG_IA64_GENERIC
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+
+#include <asm/page.h>
+
+struct ia64_machine_vector ia64_mv;
+EXPORT_SYMBOL(ia64_mv);
+
+static struct ia64_machine_vector *
+lookup_machvec (const char *name)
+{
+	extern struct ia64_machine_vector machvec_start[];
+	extern struct ia64_machine_vector machvec_end[];
+	struct ia64_machine_vector *mv;
+
+	for (mv = machvec_start; mv < machvec_end; ++mv)
+		if (strcmp (mv->name, name) == 0)
+			return mv;
+
+	return 0;
+}
+
+void
+machvec_init (const char *name)
+{
+	struct ia64_machine_vector *mv;
+
+	mv = lookup_machvec(name);
+	if (!mv) {
+		panic("generic kernel failed to find machine vector for platform %s!", name);
+	}
+	ia64_mv = *mv;
+	printk(KERN_INFO "booting generic kernel on platform %s\n", name);
+}
+
+#endif /* CONFIG_IA64_GENERIC */
+
+void
+machvec_setup (char **arg)
+{
+}
+EXPORT_SYMBOL(machvec_setup);
+
+void
+machvec_timer_interrupt (int irq, void *dev_id, struct pt_regs *regs)
+{
+}
+EXPORT_SYMBOL(machvec_timer_interrupt);
+
+void
+machvec_dma_sync_single (struct device *hwdev, dma_addr_t dma_handle, size_t size, int dir)
+{
+	mb();
+}
+EXPORT_SYMBOL(machvec_dma_sync_single);
+
+void
+machvec_dma_sync_sg (struct device *hwdev, struct scatterlist *sg, int n, int dir)
+{
+	mb();
+}
+EXPORT_SYMBOL(machvec_dma_sync_sg);

pool/shard010/C/0138075_selectionSort.c

@@ -0,0 +1,55 @@
+//selection sort using a function 
+#include <stdio.h>
+#include <stdlib.h>
+#define MAX 10
+
+int minimum(int a[],int k,int size) {
+	int min=a[k],loc=k,j;
+	
+	for(j=k+1;j<size;j++) {
+		if(min>a[j]) {
+			min=a[j];
+			loc=j;
+		}
+	}
+	return loc;
+}
+
+void selectionSort(int a[],int size) {
+	int i,loc,temp,k;
+	
+	for(i=0;i<size;i++) {
+		loc=minimum(a,i,size);
+		temp=a[i];
+		a[i]=a[loc];
+		a[loc]=temp;
+				
+		printf("\nResult after Pass %d -->\n",i+1);
+		for(k=0;k<size;k++) {
+			printf(" %d",a[k]);
+		}
+	}
+}
+
+int main() 
+{
+	int a[MAX] = {0},n=0,i;
+	system("cls");
+	
+	printf("\nEnter the number of elemenets: ");
+	scanf("%d",&n);
+	
+	printf("\nEnter the array:\n");
+	for(i=0;i<n;i++) {
+		scanf("%d",&a[i]);
+	}
+	selectionSort(a,n);
+	
+	printf("\n\nHere is the sorted array:\n");
+	for(i=0;i<n;i++) {
+		printf(" %d",a[i]);
+	}
+	printf("\n\n");
+	system("pause");
+	return 0;
+}

pool/shard010/C/0138076_flash.c

@@ -0,0 +1,254 @@
+/* $Id: flash.c,v 1.1.1.1 2007-05-25 06:50:08 bruce Exp $
+ * flash.c: Allow mmap access to the OBP Flash, for OBP updates.
+ *
+ * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/miscdevice.h>
+#include <linux/slab.h>
+#include <linux/fcntl.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/smp_lock.h>
+#include <linux/spinlock.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/pgtable.h>
+#include <asm/io.h>
+#include <asm/sbus.h>
+#include <asm/ebus.h>
+#include <asm/upa.h>
+
+static DEFINE_SPINLOCK(flash_lock);
+static struct {
+	unsigned long read_base;	/* Physical read address */
+	unsigned long write_base;	/* Physical write address */
+	unsigned long read_size;	/* Size of read area */
+	unsigned long write_size;	/* Size of write area */
+	unsigned long busy;		/* In use? */
+} flash;
+
+#define FLASH_MINOR	152
+
+static int
+flash_mmap(struct file *file, struct vm_area_struct *vma)
+{
+	unsigned long addr;
+	unsigned long size;
+
+	spin_lock(&flash_lock);
+	if (flash.read_base == flash.write_base) {
+		addr = flash.read_base;
+		size = flash.read_size;
+	} else {
+		if ((vma->vm_flags & VM_READ) &&
+		    (vma->vm_flags & VM_WRITE)) {
+			spin_unlock(&flash_lock);
+			return -EINVAL;
+		}
+		if (vma->vm_flags & VM_READ) {
+			addr = flash.read_base;
+			size = flash.read_size;
+		} else if (vma->vm_flags & VM_WRITE) {
+			addr = flash.write_base;
+			size = flash.write_size;
+		} else {
+			spin_unlock(&flash_lock);
+			return -ENXIO;
+		}
+	}
+	spin_unlock(&flash_lock);
+
+	if ((vma->vm_pgoff << PAGE_SHIFT) > size)
+		return -ENXIO;
+	addr = vma->vm_pgoff + (addr >> PAGE_SHIFT);
+
+	if (vma->vm_end - (vma->vm_start + (vma->vm_pgoff << PAGE_SHIFT)) > size)
+		size = vma->vm_end - (vma->vm_start + (vma->vm_pgoff << PAGE_SHIFT));
+
+	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+	if (io_remap_pfn_range(vma, vma->vm_start, addr, size, vma->vm_page_prot))
+		return -EAGAIN;
+		
+	return 0;
+}
+
+static long long
+flash_llseek(struct file *file, long long offset, int origin)
+{
+	lock_kernel();
+	switch (origin) {
+		case 0:
+			file->f_pos = offset;
+			break;
+		case 1:
+			file->f_pos += offset;
+			if (file->f_pos > flash.read_size)
+				file->f_pos = flash.read_size;
+			break;
+		case 2:
+			file->f_pos = flash.read_size;
+			break;
+		default:
+			unlock_kernel();
+			return -EINVAL;
+	}
+	unlock_kernel();
+	return file->f_pos;
+}
+
+static ssize_t
+flash_read(struct file * file, char __user * buf,
+	   size_t count, loff_t *ppos)
+{
+	unsigned long p = file->f_pos;
+	int i;
+	
+	if (count > flash.read_size - p)
+		count = flash.read_size - p;
+
+	for (i = 0; i < count; i++) {
+		u8 data = upa_readb(flash.read_base + p + i);
+		if (put_user(data, buf))
+			return -EFAULT;
+		buf++;
+	}
+
+	file->f_pos += count;
+	return count;
+}
+
+static int
+flash_open(struct inode *inode, struct file *file)
+{
+	if (test_and_set_bit(0, (void *)&flash.busy) != 0)
+		return -EBUSY;
+
+	return 0;
+}
+
+static int
+flash_release(struct inode *inode, struct file *file)
+{
+	spin_lock(&flash_lock);
+	flash.busy = 0;
+	spin_unlock(&flash_lock);
+
+	return 0;
+}
+
+static const struct file_operations flash_fops = {
+	/* no write to the Flash, use mmap
+	 * and play flash dependent tricks.
+	 */
+	.owner =	THIS_MODULE,
+	.llseek =	flash_llseek,
+	.read =		flash_read,
+	.mmap =		flash_mmap,
+	.open =		flash_open,
+	.release =	flash_release,
+};
+
+static struct miscdevice flash_dev = { FLASH_MINOR, "flash", &flash_fops };
+
+static int __init flash_init(void)
+{
+	struct sbus_bus *sbus;
+	struct sbus_dev *sdev = NULL;
+#ifdef CONFIG_PCI
+	struct linux_ebus *ebus;
+	struct linux_ebus_device *edev = NULL;
+	struct linux_prom_registers regs[2];
+	int len, nregs;
+#endif
+	int err;
+
+	for_all_sbusdev(sdev, sbus) {
+		if (!strcmp(sdev->prom_name, "flashprom")) {
+			if (sdev->reg_addrs[0].phys_addr == sdev->reg_addrs[1].phys_addr) {
+				flash.read_base = ((unsigned long)sdev->reg_addrs[0].phys_addr) |
+					(((unsigned long)sdev->reg_addrs[0].which_io)<<32UL);
+				flash.read_size = sdev->reg_addrs[0].reg_size;
+				flash.write_base = flash.read_base;
+				flash.write_size = flash.read_size;
+			} else {
+				flash.read_base = ((unsigned long)sdev->reg_addrs[0].phys_addr) |
+					(((unsigned long)sdev->reg_addrs[0].which_io)<<32UL);
+				flash.read_size = sdev->reg_addrs[0].reg_size;
+				flash.write_base = ((unsigned long)sdev->reg_addrs[1].phys_addr) |
+					(((unsigned long)sdev->reg_addrs[1].which_io)<<32UL);
+				flash.write_size = sdev->reg_addrs[1].reg_size;
+			}
+			flash.busy = 0;
+			break;
+		}
+	}
+	if (!sdev) {
+#ifdef CONFIG_PCI
+		struct linux_prom_registers *ebus_regs;
+
+		for_each_ebus(ebus) {
+			for_each_ebusdev(edev, ebus) {
+				if (!strcmp(edev->prom_node->name, "flashprom"))
+					goto ebus_done;
+			}
+		}
+	ebus_done:
+		if (!edev)
+			return -ENODEV;
+
+		ebus_regs = of_get_property(edev->prom_node, "reg", &len);
+		if (!ebus_regs || (len % sizeof(regs[0])) != 0) {
+			printk("flash: Strange reg property size %d\n", len);
+			return -ENODEV;
+		}
+
+		nregs = len / sizeof(ebus_regs[0]);
+
+		flash.read_base = edev->resource[0].start;
+		flash.read_size = ebus_regs[0].reg_size;
+
+		if (nregs == 1) {
+			flash.write_base = edev->resource[0].start;
+			flash.write_size = ebus_regs[0].reg_size;
+		} else if (nregs == 2) {
+			flash.write_base = edev->resource[1].start;
+			flash.write_size = ebus_regs[1].reg_size;
+		} else {
+			printk("flash: Strange number of regs %d\n", nregs);
+			return -ENODEV;
+		}
+
+		flash.busy = 0;
+
+#else
+		return -ENODEV;
+#endif
+	}
+
+	printk("OBP Flash: RD %lx[%lx] WR %lx[%lx]\n",
+	       flash.read_base, flash.read_size,
+	       flash.write_base, flash.write_size);
+
+	err = misc_register(&flash_dev);
+	if (err) {
+		printk(KERN_ERR "flash: unable to get misc minor\n");
+		return err;
+	}
+
+	return 0;
+}
+
+static void __exit flash_cleanup(void)
+{
+	misc_deregister(&flash_dev);
+}
+
+module_init(flash_init);
+module_exit(flash_cleanup);
+MODULE_LICENSE("GPL");

pool/shard010/C/0138077_eeze_disk_ls.c

@@ -0,0 +1,58 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include <Ecore.h>
+#include <Eeze.h>
+#include <Eeze_Disk.h>
+
+/* simple app to print disks and their mount points */
+
+int
+main(void)
+{
+   Eina_List *disks;
+   const char *syspath;
+
+   eeze_init();
+   eeze_disk_function();
+
+   disks = eeze_udev_find_by_type(EEZE_UDEV_TYPE_DRIVE_MOUNTABLE, NULL);
+   printf("Found the following mountable disks:\n");
+   EINA_LIST_FREE(disks, syspath)
+     {
+        Eeze_Disk *disk;
+
+        disk = eeze_disk_new(syspath);
+        printf("\t%s - %s:%s\n", syspath, eeze_disk_devpath_get(disk), eeze_disk_mount_point_get(disk));
+        eeze_disk_free(disk);
+        eina_stringshare_del(syspath);
+     }
+
+   disks = eeze_udev_find_by_type(EEZE_UDEV_TYPE_DRIVE_REMOVABLE, NULL);
+   printf("Found the following removable drives:\n");
+   EINA_LIST_FREE(disks, syspath)
+     {
+        Eeze_Disk *disk;
+
+        disk = eeze_disk_new(syspath);
+        printf("\t%s - %s:%s\n", syspath, eeze_disk_devpath_get(disk), eeze_disk_mount_point_get(disk));
+        eeze_disk_free(disk);
+        eina_stringshare_del(syspath);
+     }
+
+   disks = eeze_udev_find_by_type(EEZE_UDEV_TYPE_DRIVE_INTERNAL, NULL);
+   printf("Found the following internal drives:\n");
+   EINA_LIST_FREE(disks, syspath)
+     {
+        Eeze_Disk *disk;
+
+        disk = eeze_disk_new(syspath);
+        printf("\t%s - %s\n", syspath, eeze_disk_devpath_get(disk));
+        eeze_disk_free(disk);
+        eina_stringshare_del(syspath);
+     }
+   return 0;
+}

pool/shard010/C/0138078_mod-locale.c

@@ -0,0 +1,188 @@
+//
+//  File: %mod-locale.c
+//  Summary: "Native Functions for spawning and controlling processes"
+//  Section: Extension
+//  Project: "Rebol 3 Interpreter and Run-time (Ren-C branch)"
+//  Homepage: https://github.com/metaeducation/ren-c/
+//
+//=////////////////////////////////////////////////////////////////////////=//
+//
+// Copyright 2012-2017 Rebol Open Source Contributors
+// REBOL is a trademark of REBOL Technologies
+//
+// See README.md and CREDITS.md for more information.
+//
+// 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.
+//
+//=////////////////////////////////////////////////////////////////////////=//
+//
+
+#ifdef TO_WINDOWS
+    #include <windows.h>
+#endif
+#include <locale.h>
+
+// IS_ERROR might be defined in winerror.h and reb-types.h
+#ifdef IS_ERROR
+#undef IS_ERROR
+#endif
+
+#include "sys-core.h"
+#include "sys-ext.h"
+
+#include "tmp-mod-locale-first.h"
+
+
+//
+//  locale: native/export [
+//      "Get locale specific information"
+//      category [word!]
+//          {Language: English name of the language,
+//          Territory: English name of the country/region,
+//          Language*: Full localized primary name of the language
+//          Territory*: Full localized name of the country/region}
+//  ]
+//  new-words: [Language Language* Territory Territory*]
+//  new-errors: [
+//      invalid-category: [{Invalid locale category:} :arg1]
+//  ]
+//
+REBNATIVE(locale)
+//
+{
+  #ifdef TO_WINDOWS
+    LOCALE_INCLUDE_PARAMS_OF_LOCALE;
+
+    REBSTR *cat = VAL_WORD_CANON(ARG(category));
+
+    LCTYPE type;
+    if (cat == LOCALE_WORD_LANGUAGE)
+        type = LOCALE_SENGLANGUAGE;
+    else if (cat == LOCALE_WORD_LANGUAGE_P)
+        type = LOCALE_SNATIVELANGNAME;
+    else if (cat == LOCALE_WORD_TERRITORY)
+        type = LOCALE_SENGCOUNTRY;
+    else if (cat == LOCALE_WORD_TERRITORY_P)
+        type = LOCALE_SCOUNTRY;
+    else
+        fail (Error(RE_EXT_LOCALE_INVALID_CATEGORY, ARG(category), END));
+
+    int len_plus_term = GetLocaleInfo(0, type, 0, 0); // fetch needed length
+
+    WCHAR *buffer = OS_ALLOC_N(WCHAR, len_plus_term);
+
+    int len_check = GetLocaleInfo(0, type, buffer, len_plus_term);
+    assert(len_check == len_plus_term);
+    UNUSED(len_check);
+
+    REBVAL *str = rebSizedStringW(buffer, len_plus_term - 1);
+    Move_Value(D_OUT, str);
+    rebRelease(str);
+
+    return R_OUT;
+  #else
+    UNUSED(frame_);
+    fail ("Locale not implemented for non-windows");
+  #endif
+}
+
+
+//
+//  setlocale: native/export [
+//      {Set/Get current locale, just a simple wrapper around C version}
+//      return: [string! blank!]
+//      category [word!]
+//      value [string!]
+//  ]
+//  new-words: [
+//      all
+//      address
+//      collate
+//      ctype
+//      identification
+//      measurement
+//      messages
+//      monetary
+//      name
+//      numeric
+//      paper
+//      telephone
+//      time
+//  ]
+//  new-errors: [
+//  ]
+//
+REBNATIVE(setlocale)
+{
+    LOCALE_INCLUDE_PARAMS_OF_SETLOCALE;
+
+    struct cat_pair {
+        REBSTR *word;
+        int cat;
+    } ctypes [] = {
+        {LOCALE_WORD_ALL, LC_ALL},
+#if defined(LC_ADDRESS) // GNU extension
+        {LOCALE_WORD_ADDRESS, LC_ADDRESS},
+#endif
+        {LOCALE_WORD_COLLATE, LC_COLLATE},
+        {LOCALE_WORD_CTYPE, LC_CTYPE},
+#if defined(LC_IDENTIFICATION) // GNU extension
+        {LOCALE_WORD_IDENTIFICATION, LC_IDENTIFICATION},
+#endif
+#if defined(LC_MEASUREMENT) // GNU extension
+        {LOCALE_WORD_MEASUREMENT, LC_MEASUREMENT},
+#endif
+#if defined(LC_MESSAGES) // GNU extension
+        {LOCALE_WORD_MESSAGES, LC_MESSAGES},
+#endif
+        {LOCALE_WORD_MONETARY, LC_MONETARY},
+#if defined(LC_NAME) // GNU extension
+        {LOCALE_WORD_NAME, LC_NAME},
+#endif
+        {LOCALE_WORD_NUMERIC, LC_NUMERIC},
+#if defined(LC_TELEPHONE) // GNU extension
+        {LOCALE_WORD_TELEPHONE, LC_TELEPHONE},
+#endif
+#if defined(LC_PAPER) // GNU extension
+        {LOCALE_WORD_PAPER, LC_PAPER},
+#endif
+        {LOCALE_WORD_TIME, LC_TIME}
+    };
+
+    REBSTR *w_cat = VAL_WORD_CANON(ARG(category));
+
+    int cat = -1; // avoid possibly uninitialized warning
+    REBCNT i = 0;
+    for (; i < sizeof (ctypes) / sizeof (ctypes[0]); ++i) {
+        if (ctypes[i].word == w_cat) {
+            cat = ctypes[i].cat;
+            break;
+        }
+    }
+    if (i == sizeof (ctypes) / sizeof (ctypes[0]))
+        fail (Error(RE_EXT_LOCALE_INVALID_CATEGORY, ARG(category), END));
+
+    const char *ret = setlocale(cat, cs_cast(VAL_BIN_AT(ARG(value))));
+    if (ret == NULL) {
+        Init_Blank(D_OUT);
+    } else {
+        REBCNT len = strlen(ret);
+        REBSER *ser = Make_Binary(len);
+        Append_Series(ser, cb_cast(ret), len);
+        Init_String(D_OUT, ser);
+    }
+
+    return R_OUT;
+}
+
+#include "tmp-mod-locale-last.h"

pool/shard010/C/0138079_cam-vertex.c

@@ -0,0 +1,30 @@
+in vec4 position;
+out vec2 Texcoord;
+uniform float angle;
+
+void main() 
+{
+	const mat4 m_projection = mat4(
+        vec4(3.0 / 4.0, 0.0, 0.0, 0.0),
+        vec4(      0.0, 1.0, 0.0, 0.0),
+        vec4(      0.0, 0.0, 0.5, 0.5),
+        vec4(      0.0, 0.0, 0.0, 1.0)
+    );
+
+    mat4 m_rotation = mat4(
+        vec4(1.0,                  0.0,                  0.0, 0.0),
+        vec4(0.0,  cos(radians(angle)),  sin(radians(angle)), 0.0),
+        vec4(0.0, -sin(radians(angle)),  cos(radians(angle)), 0.0),
+        vec4(0.0,                  0.0,                  0.0, 1.0)
+    );
+    
+    mat4 m_scale = mat4(
+        vec4(4.0 / 3.0, 0.0, 0.0, 0.0),
+        vec4(      0.0, 1.0, 0.0, 0.0),
+        vec4(      0.0, 0.0, 1.0, 0.0),
+        vec4(      0.0, 0.0, 0.0, 1.0)
+    );
+
+    gl_Position = m_projection * m_rotation * m_scale * position;
+    Texcoord = position.xy * vec2(0.5) + vec2(0.5);
+}

pool/shard010/C/0138080_ems1Form.c

@@ -0,0 +1,321 @@
+/*
+ *+
+ *  Name:
+ *     ems1Form
+
+ *  Purpose:
+ *     Form an error message from its text and components.
+
+ *  Language:
+ *     Starlink ANSI
+
+ *  Invocation:
+ *     ems1Form( text, maxlen, esctokval, clean, opstr, oplen, status )
+
+ *  Description:
+ *     Construct the final text, OPSTR( 1 : OPLEN ), of a message
+ *     using the text in TEXT, and available message tokens only.
+
+ *  Arguments:
+ *     text = char* (Given)
+ *        The input message text, with any tokens.
+ *     maxlen = const int (Given)
+ *        Maximum length of output string
+ *     esctokval = Logical (Given)
+ *        if true, token values containing % will be escaped into %%
+ *        to enable sprintf processing to be performed on the expanded
+ *        string subsequently.
+ *     clean = logical (Given)
+ *        if the string is to be 'cleaned'
+ *     opstr = char* (Returned)
+ *        Resultant message text, with parsed tokens.
+ *     oplen = int* (Returned)
+ *        The filled length of OPSTR.
+ *     status = int* (Returned)
+ *        The global status.
+
+ *  Algorithm:
+ *     -  Parse the message text, TEXT, and copy it into OPSTR, making
+ *     translations for token escapes.
+ *     -  The message length is returned in OPLEN.
+
+ *  Notes:
+ *     The code assumes "%" is the escape character to be doubled up in
+ *     token values. This is done for simplicity and can easily be made
+ *     generic by changing esctokval to be a const char *.
+
+ *  Copyright:
+ *     Copyright (C) 1982 Science & Engineering Research Council.
+ *     Copyright (C) 2001 Central Laboratory of the Research Councils.
+ *     Copyright (C) 2006 Particle Physics & Astronomy Research Council.
+ *     Copyright (C) 2008 Science and Technology Facilities Council.
+ *     All Rights Reserved.
+
+ *  Licence:
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation; either version 2 of
+ *     the License, or (at your option) any later version.
+ *
+ *     This program is distributed in the hope that it will be
+ *     useful,but WITHOUT ANY WARRANTY; without even the implied
+ *     warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *     PURPOSE. See the GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program; if not, write to the Free Software
+ *     Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA
+ *     02110-1301, USA
+
+ *  Authors:
+ *     JRG: Jack Giddings (UCL)
+ *     BDK: Dennis Kelly (ROE)
+ *     AJC: Alan Chipperfield (STARLINK)
+ *     PCTR: P.C.T. Rees (STARLINK)
+ *     RTP: R.T. Platon (STARLINK)
+ *     TIMJ: Tim Jenness (JAC, Hawaii)
+ *     PWD: Peter W. Draper (JAC, Durham University)
+ *     {enter_new_authors_here}
+
+ *  History:
+ *     3-JAN-1982 (JRG):
+ *        Original FORTRAN version.
+ *     14-FEB-2001 (RTP)
+ *        Rewritten in C based on the Fortran routine EMS1_PFORM
+ *      5-MAR-2001 (AJC):
+ *        Set returned value OPLEN
+ *        Use a temporary buffer for text amnipulation
+ *        Use ems1Putc to append to string
+ *        Add 'maxlen' argument
+ *        Remove 'param' argument
+ *     13-AUG-2001 (AJC):
+ *        #include stdlib.h and ems1.h
+ *     23-FEB-2006 (TIMJ):
+ *        Use starMem
+ *     15-MAY-2008 (PWD):
+ *        Remove ems_msgtb.h include, not needed.
+ *     23-DEC-2008 (TIMJ):
+ *        use isprint() to filter out non-printable characters. Rather
+ *        than checking for char < 32. Add argument to enable escaping
+ *        of % characters in token values. Required for safe sprintf processing.
+ *     {enter_further_changes_here}
+
+ *  Bugs:
+ *     {note_any_bugs_here}
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "sae_par.h"                 /* Standard SAE constants */
+#include "ems_par.h"                 /* EMS_ public constants */
+#include "ems_sys.h"                 /* EMS_ private constants */
+#include "ems1.h"                    /* EMS1 function prototypes */
+#include "ems.h"
+#include "star/mem.h"
+
+void ems1Form( const char *text, const int maxlen, Logical esctokval,
+               Logical clean, char *opstr, int *oplen,
+               int *status __attribute__((unused)) )
+{
+    Logical literl;              /* Whether a literal token escape */
+
+    int curpos;                  /* Current character pointer */
+    int lstat;                   /* Local status */
+    int lstpos;                  /* Previous value of CURPOS */
+    int oppos;                   /* Position in OP string */
+    int namlen;                  /* Token name length */
+    int pstat;                   /* Local status */
+    int texlen;                  /* TEXSTR length */
+    int tkvlen;                  /* TOKVAL length */
+    int j;
+    int i;
+
+    char namstr[ EMS__SZMSG + 1 ] = ""; /* Token name string */
+    char tokval[ EMS__SZTOK + 1 ] = ""; /* Token value string */
+    char tstr[EMS__SZTOK + 1 ];  /* Escaped token value temp string buffer */
+    const char tokescval = '%';  /* Escape value to look for in token values */
+    char *texbuf;                /* Ptr to temporary text buffer */
+
+    TRACE("ems1Form");
+
+    /*  Initialise the returned message. */
+    opstr[0] = '\0';
+    *oplen = 0;
+
+    /*  Get the length of the given string. */
+    if (!text) {
+      strcpy( opstr, "Internal malloc failure. Abort!" );
+      *oplen = strlen( opstr );
+      /*  Clear the message token table. */
+      ems1Ktok();
+      return;
+    }
+    texlen = strlen( text );
+
+    /*  Check for an empty string. */
+    if ( texlen > 0 ) {
+
+        /*  Use a temporary text buffer which can be modified */
+        texbuf = starMalloc( texlen + 1 );
+        if (!texbuf) {
+          strcpy( opstr, "Internal malloc failure. Abort!" );
+          *oplen = strlen( opstr );
+          /*  Clear the message token table. */
+          ems1Ktok();
+          return;
+        }
+        strcpy( texbuf, text );
+
+        /*  Initialise the text pointers and local status. */
+        literl = FALSE;
+        curpos = -1;
+        lstpos = -1;
+        oppos = -1;
+        lstat = SAI__OK;
+        pstat = SAI__OK;
+
+        /*  Parse and expand the message text.
+         *  DO WHILE loop.
+         */
+        while ( pstat == SAI__OK && curpos < texlen ) {
+
+            /*  Find the next occurrence of an escape character. */
+            ems1Gesc( EMS__TOKEC, texbuf, &curpos );
+
+            if ( curpos == -1 ) {
+
+                /*  No more escape characters have been found, so append all
+                 *  the text that remains to the returned message text and
+                 *  exit the loop.
+                 */
+                ems1Putc( &texbuf[ lstpos+1 ], maxlen, opstr, &oppos, &pstat );
+                break;
+
+            } else {
+                /*  A token escape has been found, so check if it is a double
+                 *  token escape.
+                 */
+                if ( literl && curpos == lstpos + 1 ) {
+                    /*  A double token escape, so do nothing except update
+                     *  CURPOS and reset the literal token escape flag.
+                     */
+                    literl = FALSE;
+
+                } else {
+
+                    /*  Reset the literal token escape flag. */
+                    literl = FALSE;
+
+                    /*  Append any text prior to the escape character. */
+                    /*  Terminate the string to be copied at the escape */
+                    if ( curpos - lstpos > 0 ) {
+                        texbuf[ curpos ] = '\0';
+                        (void)ems1Putc( &texbuf[ lstpos+1 ], maxlen, opstr,
+                                        &oppos, &pstat );
+
+                        /*  Overwrite the terminator - actual character
+                         *  doesn't matter */
+                        texbuf[ curpos ] = '^';
+                    }
+
+                    /*  Find the token name. */
+                    ems1Gnam( texbuf, &curpos, namstr, &namlen, &lstat );
+
+                    /*  Check that a token name exists. */
+                    if ( lstat != SAI__OK ) {
+
+                        /*  The name string has been over-run, so indicate
+                         *  this in the message text. */
+                        ems1Putc( EMS__TOKEC, maxlen, opstr, &oppos, &pstat );
+                        ems1Putc( "<", maxlen, opstr, &oppos, &pstat );
+                        ems1Putc( namstr, maxlen, opstr, &oppos, &pstat );
+                        ems1Putc( ">", maxlen, opstr, &oppos, &pstat );
+
+                        /*  Reset the local status. */
+                        lstat = SAI__OK;
+
+                    } else if ( namlen > 0 ) {
+
+                        /*  There is a name, so get the token value. */
+                        if ( ems1Gtok( namstr, tokval, &tkvlen ) ) {
+
+                          /* if there is an escape character in the token
+                             itself we need to double it up. This is used
+                             to enable a % in the token to be retained
+                             after sprintf processing */
+                          if ( esctokval ) {
+                            j=0;
+                            for ( i = 0; i < tkvlen; i++) {
+                              /* if we have found the escape char we
+                                 insert an additional one */
+                              if (tokval[i] == tokescval) {
+                                tstr[j] = tokescval;
+                                j++;
+                              }
+                              /* copy the character that was tested */
+                              tstr[j] = tokval[i];
+                              j++;
+                            }
+                            tkvlen = j;
+                            tstr[j] = '\0';
+                          } else {
+                            strncpy( tstr, tokval, sizeof(tstr));
+                            tstr[tkvlen] = '\0';
+                          }
+
+                            /*  Append the token value to the expanded message
+                             *  text. */
+                            ems1Putc( tstr, maxlen, opstr, &oppos, &pstat );
+
+                        } else {
+                            /*  The message token is not defined, so indicate
+                             *  this in the message text. */
+                            ems1Putc( EMS__TOKEC, maxlen, opstr, &oppos,
+                                      &pstat );
+                            ems1Putc( "<", maxlen, opstr, &oppos, &pstat );
+                            ems1Putc( namstr, maxlen, opstr, &oppos, &pstat );
+                            ems1Putc( ">", maxlen, opstr, &oppos, &pstat );
+                        }
+
+                    } else {
+
+                        /*  There is an isolated token escape character in the
+                         *  string, so set the literal token escape flag and
+                         *  append the character. */
+                        literl = TRUE;
+                        ems1Putc( EMS__TOKEC, maxlen, opstr, &oppos, &pstat );
+                    }
+                }
+
+                /*  Update LSTPOS. */
+                lstpos = curpos;
+            }
+        }
+        starFree( texbuf );
+    }
+
+    /*  Get the length of the string and, if CLEAN is TRUE, ensure the
+     *  returned message string contains no unprintable characters.
+     */
+    *oplen = strlen( opstr );
+    if ( clean ) {
+        int i;
+        for ( i = 0; i < *oplen; i++ ) {
+          if ( !isprint(opstr[ i ]) ) opstr[ i ] = ' ';
+        }
+    }
+
+    DEBUG( "ems1Form", "Error Message: '%s'\n", opstr );
+#if PRINT_ERRMESS
+    fprintf( OP_STREAM, "! %s\n", opstr );
+    fflush( OP_STREAM );
+#endif
+
+    /*  Clear the message token table. */
+    ems1Ktok();
+
+    return;
+}

pool/shard010/C/0138081_sunxi_sram.c

@@ -0,0 +1,284 @@
+/*
+ * Allwinner SoCs SRAM Controller Driver
+ *
+ * Copyright (C) 2015 Maxime Ripard
+ *
+ * Author: Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/debugfs.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+
+#include <linux/soc/sunxi/sunxi_sram.h>
+
+struct sunxi_sram_func {
+	char	*func;
+	u8	val;
+};
+
+struct sunxi_sram_data {
+	char			*name;
+	u8			reg;
+	u8			offset;
+	u8			width;
+	struct sunxi_sram_func	*func;
+	struct list_head	list;
+};
+
+struct sunxi_sram_desc {
+	struct sunxi_sram_data	data;
+	bool			claimed;
+};
+
+#define SUNXI_SRAM_MAP(_val, _func)				\
+	{							\
+		.func = _func,					\
+		.val = _val,					\
+	}
+
+#define SUNXI_SRAM_DATA(_name, _reg, _off, _width, ...)		\
+	{							\
+		.name = _name,					\
+		.reg = _reg,					\
+		.offset = _off,					\
+		.width = _width,				\
+		.func = (struct sunxi_sram_func[]){		\
+			__VA_ARGS__, { } },			\
+	}
+
+static struct sunxi_sram_desc sun4i_a10_sram_a3_a4 = {
+	.data	= SUNXI_SRAM_DATA("A3-A4", 0x4, 0x4, 2,
+				  SUNXI_SRAM_MAP(0, "cpu"),
+				  SUNXI_SRAM_MAP(1, "emac")),
+};
+
+static struct sunxi_sram_desc sun4i_a10_sram_d = {
+	.data	= SUNXI_SRAM_DATA("D", 0x4, 0x0, 1,
+				  SUNXI_SRAM_MAP(0, "cpu"),
+				  SUNXI_SRAM_MAP(1, "usb-otg")),
+};
+
+static const struct of_device_id sunxi_sram_dt_ids[] = {
+	{
+		.compatible	= "allwinner,sun4i-a10-sram-a3-a4",
+		.data		= &sun4i_a10_sram_a3_a4.data,
+	},
+	{
+		.compatible	= "allwinner,sun4i-a10-sram-d",
+		.data		= &sun4i_a10_sram_d.data,
+	},
+	{}
+};
+
+static struct device *sram_dev;
+static LIST_HEAD(claimed_sram);
+static DEFINE_SPINLOCK(sram_lock);
+static void __iomem *base;
+
+static int sunxi_sram_show(struct seq_file *s, void *data)
+{
+	struct device_node *sram_node, *section_node;
+	const struct sunxi_sram_data *sram_data;
+	const struct of_device_id *match;
+	struct sunxi_sram_func *func;
+	const __be32 *sram_addr_p, *section_addr_p;
+	u32 val;
+
+	seq_puts(s, "Allwinner sunXi SRAM\n");
+	seq_puts(s, "--------------------\n\n");
+
+	for_each_child_of_node(sram_dev->of_node, sram_node) {
+		sram_addr_p = of_get_address(sram_node, 0, NULL, NULL);
+
+		seq_printf(s, "sram@%08x\n",
+			   be32_to_cpu(*sram_addr_p));
+
+		for_each_child_of_node(sram_node, section_node) {
+			match = of_match_node(sunxi_sram_dt_ids, section_node);
+			if (!match)
+				continue;
+			sram_data = match->data;
+
+			section_addr_p = of_get_address(section_node, 0,
+							NULL, NULL);
+
+			seq_printf(s, "\tsection@%04x\t(%s)\n",
+				   be32_to_cpu(*section_addr_p),
+				   sram_data->name);
+
+			val = readl(base + sram_data->reg);
+			val >>= sram_data->offset;
+			val &= sram_data->width;
+
+			for (func = sram_data->func; func->func; func++) {
+				seq_printf(s, "\t\t%s%c\n", func->func,
+					   func->val == val ? '*' : ' ');
+			}
+		}
+
+		seq_puts(s, "\n");
+	}
+
+	return 0;
+}
+
+static int sunxi_sram_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, sunxi_sram_show, inode->i_private);
+}
+
+static const struct file_operations sunxi_sram_fops = {
+	.open = sunxi_sram_open,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = single_release,
+};
+
+static inline struct sunxi_sram_desc *to_sram_desc(const struct sunxi_sram_data *data)
+{
+	return container_of(data, struct sunxi_sram_desc, data);
+}
+
+static const struct sunxi_sram_data *sunxi_sram_of_parse(struct device_node *node,
+							 unsigned int *value)
+{
+	const struct of_device_id *match;
+	struct of_phandle_args args;
+	int ret;
+
+	ret = of_parse_phandle_with_fixed_args(node, "allwinner,sram", 1, 0,
+					       &args);
+	if (ret)
+		return ERR_PTR(ret);
+
+	if (!of_device_is_available(args.np)) {
+		ret = -EBUSY;
+		goto err;
+	}
+
+	if (value)
+		*value = args.args[0];
+
+	match = of_match_node(sunxi_sram_dt_ids, args.np);
+	if (!match) {
+		ret = -EINVAL;
+		goto err;
+	}
+
+	of_node_put(args.np);
+	return match->data;
+
+err:
+	of_node_put(args.np);
+	return ERR_PTR(ret);
+}
+
+int sunxi_sram_claim(struct device *dev)
+{
+	const struct sunxi_sram_data *sram_data;
+	struct sunxi_sram_desc *sram_desc;
+	unsigned int device;
+	u32 val, mask;
+
+	if (IS_ERR(base))
+		return -EPROBE_DEFER;
+
+	if (!dev || !dev->of_node)
+		return -EINVAL;
+
+	sram_data = sunxi_sram_of_parse(dev->of_node, &device);
+	if (IS_ERR(sram_data))
+		return PTR_ERR(sram_data);
+
+	sram_desc = to_sram_desc(sram_data);
+
+	spin_lock(&sram_lock);
+
+	if (sram_desc->claimed) {
+		spin_unlock(&sram_lock);
+		return -EBUSY;
+	}
+
+	mask = GENMASK(sram_data->offset + sram_data->width, sram_data->offset);
+	val = readl(base + sram_data->reg);
+	val &= ~mask;
+	writel(val | ((device << sram_data->offset) & mask),
+	       base + sram_data->reg);
+
+	spin_unlock(&sram_lock);
+
+	return 0;
+}
+EXPORT_SYMBOL(sunxi_sram_claim);
+
+int sunxi_sram_release(struct device *dev)
+{
+	const struct sunxi_sram_data *sram_data;
+	struct sunxi_sram_desc *sram_desc;
+
+	if (!dev || !dev->of_node)
+		return -EINVAL;
+
+	sram_data = sunxi_sram_of_parse(dev->of_node, NULL);
+	if (IS_ERR(sram_data))
+		return -EINVAL;
+
+	sram_desc = to_sram_desc(sram_data);
+
+	spin_lock(&sram_lock);
+	sram_desc->claimed = false;
+	spin_unlock(&sram_lock);
+
+	return 0;
+}
+EXPORT_SYMBOL(sunxi_sram_release);
+
+static int sunxi_sram_probe(struct platform_device *pdev)
+{
+	struct resource *res;
+	struct dentry *d;
+
+	sram_dev = &pdev->dev;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	base = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(base))
+		return PTR_ERR(base);
+
+	of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev);
+
+	d = debugfs_create_file("sram", S_IRUGO, NULL, NULL,
+				&sunxi_sram_fops);
+	if (!d)
+		return -ENOMEM;
+
+	return 0;
+}
+
+static const struct of_device_id sunxi_sram_dt_match[] = {
+	{ .compatible = "allwinner,sun4i-a10-sram-controller" },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, sunxi_sram_dt_match);
+
+static struct platform_driver sunxi_sram_driver = {
+	.driver = {
+		.name		= "sunxi-sram",
+		.of_match_table	= sunxi_sram_dt_match,
+	},
+	.probe	= sunxi_sram_probe,
+};
+module_platform_driver(sunxi_sram_driver);
+
+MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
+MODULE_DESCRIPTION("Allwinner sunXi SRAM Controller Driver");
+MODULE_LICENSE("GPL");

pool/shard010/C/0138082_ping_test.c

@@ -0,0 +1,229 @@
+/*
+ * GPL HEADER START
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License version 2 for more details (a copy is included
+ * in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; If not, see
+ * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * GPL HEADER END
+ */
+/*
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, Intel Corporation.
+ */
+/*
+ * This file is part of Lustre, http://www.lustre.org/
+ * Lustre is a trademark of Sun Microsystems, Inc.
+ *
+ * lnet/selftest/conctl.c
+ *
+ * Test client & Server
+ *
+ * Author: Liang Zhen <liangzhen@clusterfs.com>
+ */
+
+#include "selftest.h"
+
+#define LST_PING_TEST_MAGIC     0xbabeface
+
+int ping_srv_workitems = SFW_TEST_WI_MAX;
+CFS_MODULE_PARM(ping_srv_workitems, "i", int, 0644, "# PING server workitems");
+
+typedef struct {
+	spinlock_t	pnd_lock;	/* serialize */
+	int		pnd_counter;	/* sequence counter */
+} lst_ping_data_t;
+
+static lst_ping_data_t  lst_ping_data;
+
+static int
+ping_client_init(sfw_test_instance_t *tsi)
+{
+	sfw_session_t *sn = tsi->tsi_batch->bat_session;
+
+	LASSERT(tsi->tsi_is_client);
+	LASSERT(sn != NULL && (sn->sn_features & ~LST_FEATS_MASK) == 0);
+
+	spin_lock_init(&lst_ping_data.pnd_lock);
+	lst_ping_data.pnd_counter = 0;
+
+	return 0;
+}
+
+static void
+ping_client_fini (sfw_test_instance_t *tsi)
+{
+        sfw_session_t *sn = tsi->tsi_batch->bat_session;
+        int            errors;
+
+        LASSERT (sn != NULL);
+        LASSERT (tsi->tsi_is_client);
+
+	errors = atomic_read(&sn->sn_ping_errors);
+        if (errors)
+                CWARN ("%d pings have failed.\n", errors);
+        else
+                CDEBUG (D_NET, "Ping test finished OK.\n");
+}
+
+static int
+ping_client_prep_rpc(sfw_test_unit_t *tsu,
+		     lnet_process_id_t dest, srpc_client_rpc_t **rpc)
+{
+	srpc_ping_reqst_t   *req;
+	sfw_test_instance_t *tsi = tsu->tsu_instance;
+	sfw_session_t       *sn  = tsi->tsi_batch->bat_session;
+	struct timeval       tv;
+	int		     rc;
+
+	LASSERT(sn != NULL);
+	LASSERT((sn->sn_features & ~LST_FEATS_MASK) == 0);
+
+	rc = sfw_create_test_rpc(tsu, dest, sn->sn_features, 0, 0, rpc);
+        if (rc != 0)
+                return rc;
+
+        req = &(*rpc)->crpc_reqstmsg.msg_body.ping_reqst;
+
+        req->pnr_magic = LST_PING_TEST_MAGIC;
+
+	spin_lock(&lst_ping_data.pnd_lock);
+	req->pnr_seq = lst_ping_data.pnd_counter++;
+	spin_unlock(&lst_ping_data.pnd_lock);
+
+	cfs_fs_timeval(&tv);
+	req->pnr_time_sec  = tv.tv_sec;
+	req->pnr_time_usec = tv.tv_usec;
+
+	return rc;
+}
+
+static void
+ping_client_done_rpc (sfw_test_unit_t *tsu, srpc_client_rpc_t *rpc)
+{
+        sfw_test_instance_t *tsi = tsu->tsu_instance;
+        sfw_session_t       *sn = tsi->tsi_batch->bat_session;
+        srpc_ping_reqst_t   *reqst = &rpc->crpc_reqstmsg.msg_body.ping_reqst;
+        srpc_ping_reply_t   *reply = &rpc->crpc_replymsg.msg_body.ping_reply;
+        struct timeval       tv;
+
+        LASSERT (sn != NULL);
+
+        if (rpc->crpc_status != 0) {
+                if (!tsi->tsi_stopping) /* rpc could have been aborted */
+			atomic_inc(&sn->sn_ping_errors);
+                CERROR ("Unable to ping %s (%d): %d\n",
+                        libcfs_id2str(rpc->crpc_dest),
+                        reqst->pnr_seq, rpc->crpc_status);
+                return;
+	}
+
+        if (rpc->crpc_replymsg.msg_magic != SRPC_MSG_MAGIC) {
+                __swab32s(&reply->pnr_seq);
+                __swab32s(&reply->pnr_magic);
+                __swab32s(&reply->pnr_status);
+        }
+
+        if (reply->pnr_magic != LST_PING_TEST_MAGIC) {
+                rpc->crpc_status = -EBADMSG;
+		atomic_inc(&sn->sn_ping_errors);
+                CERROR ("Bad magic %u from %s, %u expected.\n",
+                        reply->pnr_magic, libcfs_id2str(rpc->crpc_dest),
+                        LST_PING_TEST_MAGIC);
+                return;
+	}
+
+        if (reply->pnr_seq != reqst->pnr_seq) {
+                rpc->crpc_status = -EBADMSG;
+		atomic_inc(&sn->sn_ping_errors);
+                CERROR ("Bad seq %u from %s, %u expected.\n",
+                        reply->pnr_seq, libcfs_id2str(rpc->crpc_dest),
+                        reqst->pnr_seq);
+                return;
+        }
+
+        cfs_fs_timeval(&tv);
+        CDEBUG (D_NET, "%d reply in %u usec\n", reply->pnr_seq,
+                (unsigned)((tv.tv_sec - (unsigned)reqst->pnr_time_sec) * 1000000
+                           + (tv.tv_usec - reqst->pnr_time_usec)));
+        return;
+}
+
+static int
+ping_server_handle(struct srpc_server_rpc *rpc)
+{
+	struct srpc_service	*sv  = rpc->srpc_scd->scd_svc;
+        srpc_msg_t        *reqstmsg = &rpc->srpc_reqstbuf->buf_msg;
+	srpc_msg_t	  *replymsg = &rpc->srpc_replymsg;
+        srpc_ping_reqst_t *req = &reqstmsg->msg_body.ping_reqst;
+        srpc_ping_reply_t *rep = &rpc->srpc_replymsg.msg_body.ping_reply;
+
+        LASSERT (sv->sv_id == SRPC_SERVICE_PING);
+
+        if (reqstmsg->msg_magic != SRPC_MSG_MAGIC) {
+                LASSERT (reqstmsg->msg_magic == __swab32(SRPC_MSG_MAGIC));
+
+                __swab32s(&req->pnr_seq);
+                __swab32s(&req->pnr_magic);
+                __swab64s(&req->pnr_time_sec);
+                __swab64s(&req->pnr_time_usec);
+        }
+        LASSERT (reqstmsg->msg_type == srpc_service2request(sv->sv_id));
+
+        if (req->pnr_magic != LST_PING_TEST_MAGIC) {
+                CERROR ("Unexpect magic %08x from %s\n",
+                        req->pnr_magic, libcfs_id2str(rpc->srpc_peer));
+                return -EINVAL;
+        }
+
+        rep->pnr_seq   = req->pnr_seq;
+        rep->pnr_magic = LST_PING_TEST_MAGIC;
+
+	if ((reqstmsg->msg_ses_feats & ~LST_FEATS_MASK) != 0) {
+		replymsg->msg_ses_feats = LST_FEATS_MASK;
+		rep->pnr_status = EPROTO;
+		return 0;
+	}
+
+	replymsg->msg_ses_feats = reqstmsg->msg_ses_feats;
+
+	CDEBUG(D_NET, "Get ping %d from %s\n",
+	       req->pnr_seq, libcfs_id2str(rpc->srpc_peer));
+	return 0;
+}
+
+sfw_test_client_ops_t ping_test_client;
+void ping_init_test_client(void)
+{
+        ping_test_client.tso_init     = ping_client_init;
+        ping_test_client.tso_fini     = ping_client_fini;
+        ping_test_client.tso_prep_rpc = ping_client_prep_rpc;
+        ping_test_client.tso_done_rpc = ping_client_done_rpc;
+}
+
+srpc_service_t ping_test_service;
+void ping_init_test_service(void)
+{
+	ping_test_service.sv_id       = SRPC_SERVICE_PING;
+	ping_test_service.sv_name     = "ping_test";
+	ping_test_service.sv_handler  = ping_server_handle;
+	ping_test_service.sv_wi_total = ping_srv_workitems;
+}

pool/shard010/C/0138083_ltt-facility-loader-network.c

@@ -0,0 +1,66 @@
+/*
+ * ltt-facility-loader-network.c
+ *
+ * (C) Copyright  2005 - 
+ *          Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ *
+ * Contains the LTT facility loader.
+ *
+ */
+
+
+#include <linux/ltt-facilities.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/config.h>
+#include "ltt-facility-loader-network.h"
+
+
+#ifdef CONFIG_LTT
+
+EXPORT_SYMBOL(LTT_FACILITY_SYMBOL);
+EXPORT_SYMBOL(LTT_FACILITY_CHECKSUM_SYMBOL);
+
+static const char ltt_facility_name[] = LTT_FACILITY_NAME;
+
+#define SYMBOL_STRING(sym) #sym
+
+static struct ltt_facility facility = {
+	.name = ltt_facility_name,
+	.num_events = LTT_FACILITY_NUM_EVENTS,
+	.checksum = LTT_FACILITY_CHECKSUM,
+	.symbol = SYMBOL_STRING(LTT_FACILITY_SYMBOL),
+};
+
+static int __init facility_init(void)
+{
+	printk(KERN_INFO "LTT : ltt-facility-network init in kernel\n");
+
+	LTT_FACILITY_SYMBOL = ltt_facility_kernel_register(&facility);
+	LTT_FACILITY_CHECKSUM_SYMBOL = LTT_FACILITY_SYMBOL;
+	
+	return LTT_FACILITY_SYMBOL;
+}
+
+#ifndef MODULE
+__initcall(facility_init);
+#else
+module_init(facility_init);
+static void __exit facility_exit(void)
+{
+	int err;
+
+	err = ltt_facility_unregister(LTT_FACILITY_SYMBOL);
+	if(err != 0)
+		printk(KERN_ERR "LTT : Error in unregistering facility.\n");
+
+}
+module_exit(facility_exit)
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Facility");
+
+#endif //MODULE
+
+#endif //CONFIG_LTT

pool/shard010/C/0138084_t-sgn.c

@@ -0,0 +1,64 @@
+/*
+    Copyright (C) 2009 William Hart
+
+    This file is part of FLINT.
+
+    FLINT is free software: you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.  See <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "ulong_extras.h"
+#include "fmpz.h"
+
+int
+main(void)
+{
+    int i, result;
+    FLINT_TEST_INIT(state);
+
+    flint_printf("sgn....");
+    fflush(stdout);
+
+    
+
+    for (i = 0; i < 10000 * flint_test_multiplier(); i++)
+    {
+        fmpz_t a;
+        mpz_t b;
+        mp_size_t r1, r2;
+
+        fmpz_init(a);
+
+        mpz_init(b);
+
+        fmpz_randtest(a, state, 200);
+
+        fmpz_get_mpz(b, a);
+
+        r1 = fmpz_sgn(a);
+        r2 = mpz_sgn(b);
+        result = (r1 == r2);
+
+        if (!result)
+        {
+            flint_printf("FAIL:\n");
+            gmp_printf("b = %Zd\n", b);
+            abort();
+        }
+
+        fmpz_clear(a);
+
+        mpz_clear(b);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}

pool/shard010/C/0138085_shichif.c

@@ -0,0 +1,218 @@
+/*							shichif.c
+ *
+ *	Hyperbolic sine and cosine integrals
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * float x, Chi, Shi;
+ *
+ * shichi( x, &Chi, &Shi );
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Approximates the integrals
+ *
+ *                            x
+ *                            -
+ *                           | |   cosh t - 1
+ *   Chi(x) = eul + ln x +   |    -----------  dt,
+ *                         | |          t
+ *                          -
+ *                          0
+ *
+ *               x
+ *               -
+ *              | |  sinh t
+ *   Shi(x) =   |    ------  dt
+ *            | |       t
+ *             -
+ *             0
+ *
+ * where eul = 0.57721566490153286061 is Euler's constant.
+ * The integrals are evaluated by power series for x < 8
+ * and by Chebyshev expansions for x between 8 and 88.
+ * For large x, both functions approach exp(x)/2x.
+ * Arguments greater than 88 in magnitude return MAXNUM.
+ *
+ *
+ * ACCURACY:
+ *
+ * Test interval 0 to 88.
+ *                      Relative error:
+ * arithmetic   function  # trials      peak         rms
+ *    IEEE         Shi      20000       3.5e-7      7.0e-8
+ *        Absolute error, except relative when |Chi| > 1:
+ *    IEEE         Chi      20000       3.8e-7      7.6e-8
+ */
+
+/*
+Cephes Math Library Release 2.2:  July, 1992
+Copyright 1984, 1987, 1992 by Stephen L. Moshier
+Direct inquiries to 30 Frost Street, Cambridge, MA 02140
+*/
+
+
+#include "mconf.h"
+
+/* x exp(-x) shi(x), inverted interval 8 to 18 */
+static float S1[] = {
+-3.56699611114982536845E-8,
+ 1.44818877384267342057E-7,
+ 7.82018215184051295296E-7,
+-5.39919118403805073710E-6,
+-3.12458202168959833422E-5,
+ 8.90136741950727517826E-5,
+ 2.02558474743846862168E-3,
+ 2.96064440855633256972E-2,
+ 1.11847751047257036625E0
+};
+
+/* x exp(-x) shi(x), inverted interval 18 to 88 */
+static float S2[] = {
+ 1.69050228879421288846E-8,
+ 1.25391771228487041649E-7,
+ 1.16229947068677338732E-6,
+ 1.61038260117376323993E-5,
+ 3.49810375601053973070E-4,
+ 1.28478065259647610779E-2,
+ 1.03665722588798326712E0
+};
+
+
+/* x exp(-x) chin(x), inverted interval 8 to 18 */
+static float C1[] = {
+ 1.31458150989474594064E-8,
+-4.75513930924765465590E-8,
+-2.21775018801848880741E-7,
+ 1.94635531373272490962E-6,
+ 4.33505889257316408893E-6,
+-6.13387001076494349496E-5,
+-3.13085477492997465138E-4,
+ 4.97164789823116062801E-4,
+ 2.64347496031374526641E-2,
+ 1.11446150876699213025E0
+};
+
+/* x exp(-x) chin(x), inverted interval 18 to 88 */
+static float C2[] = {
+-3.00095178028681682282E-9,
+ 7.79387474390914922337E-8,
+ 1.06942765566401507066E-6,
+ 1.59503164802313196374E-5,
+ 3.49592575153777996871E-4,
+ 1.28475387530065247392E-2,
+ 1.03665693917934275131E0
+};
+
+
+
+/* Sine and cosine integrals */
+
+#define EUL 0.57721566490153286061
+extern float MACHEPF, MAXNUMF;
+
+#define fabsf(x) ( (x) < 0 ? -(x) : (x) )
+
+#ifdef ANSIC
+float logf(float ), expf(float), chbevlf(float, float *, int);
+#else
+float logf(), expf(), chbevlf();
+#endif
+
+
+
+#ifdef ANSIC
+int shichif( float xx, float *si, float *ci )
+#else
+int shichif( xx, si, ci )
+double xx;
+float *si, *ci;
+#endif
+{
+float x, k, z, c, s, a;
+short sign;
+
+x = xx;
+if( x < 0.0 )
+	{
+	sign = -1;
+	x = -x;
+	}
+else
+	sign = 0;
+
+
+if( x == 0.0 )
+	{
+	*si = 0.0;
+	*ci = -MAXNUMF;
+	return( 0 );
+	}
+
+if( x >= 8.0 )
+	goto chb;
+
+z = x * x;
+
+/*	Direct power series expansion	*/
+
+a = 1.0;
+s = 1.0;
+c = 0.0;
+k = 2.0;
+
+do
+	{
+	a *= z/k;
+	c += a/k;
+	k += 1.0;
+	a /= k;
+	s += a/k;
+	k += 1.0;
+	}
+while( fabsf(a/s) > MACHEPF );
+
+s *= x;
+goto done;
+
+
+chb:
+
+if( x < 18.0 )
+	{
+	a = (576.0/x - 52.0)/10.0;
+	k = expf(x) / x;
+	s = k * chbevlf( a, S1, 9 );
+	c = k * chbevlf( a, C1, 10 );
+	goto done;
+	}
+
+if( x <= 88.0 )
+	{
+	a = (6336.0/x - 212.0)/70.0;
+	k = expf(x) / x;
+	s = k * chbevlf( a, S2, 7 );
+	c = k * chbevlf( a, C2, 7 );
+	goto done;
+	}
+else
+	{
+	if( sign )
+		*si = -MAXNUMF;
+	else
+		*si = MAXNUMF;
+	*ci = MAXNUMF;
+	return(0);
+	}
+done:
+if( sign )
+	s = -s;
+
+*si = s;
+
+*ci = EUL + logf(x) + c;
+return(0);
+}

pool/shard010/C/0138086_dirhistory_menu.c

@@ -0,0 +1,132 @@
+/* vifm
+ * Copyright (C) 2001 Ken Steen.
+ * Copyright (C) 2011 xaizek.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "dirhistory_menu.h"
+
+#include <stddef.h> /* NULL */
+#include <string.h> /* strdup() */
+
+#include "../cfg/config.h"
+#include "../ui/ui.h"
+#include "../utils/fs.h"
+#include "../utils/str.h"
+#include "../utils/string_array.h"
+#include "../filelist.h"
+#include "menus.h"
+
+static int execute_dirhistory_cb(FileView *view, menu_info *m);
+
+int
+show_history_menu(FileView *view)
+{
+	int i;
+	int need_cleanup;
+
+	static menu_info m;
+	init_menu_info(&m, strdup("Directory History"),
+			strdup("History disabled or empty"));
+
+	m.execute_handler = &execute_dirhistory_cb;
+
+	need_cleanup = 0;
+	for(i = 0; i < view->history_num && i < cfg.history_len; i++)
+	{
+		int j;
+		if(view->history[i].dir[0] == '\0')
+			break;
+		for(j = i + 1; j < view->history_num && j < cfg.history_len; j++)
+			if(stroscmp(view->history[i].dir, view->history[j].dir) == 0)
+				break;
+		if(j < view->history_num && j < cfg.history_len)
+			continue;
+		if(!is_valid_dir(view->history[i].dir))
+		{
+			/* "Mark" directory as non-existent. */
+			free(view->history[i].dir);
+			view->history[i].dir = NULL;
+			need_cleanup = 1;
+			continue;
+		}
+
+		/* Change the current dir to reflect the current file. */
+		if(stroscmp(view->history[i].dir, view->curr_dir) == 0)
+		{
+			(void)replace_string(&view->history[i].file, get_current_file_name(view));
+			m.pos = m.len;
+		}
+
+		m.len = add_to_string_array(&m.items, m.len, 1, view->history[i].dir);
+	}
+
+	if(need_cleanup)
+	{
+		int i, j;
+
+		/* Erase non existing directories from history. */
+		j = 0;
+		for(i = 0; i < view->history_num && i < cfg.history_len; ++i)
+		{
+			if(view->history[i].dir == NULL)
+			{
+				free(view->history[i].file);
+				continue;
+			}
+
+			if(j != i)
+			{
+				view->history[j] = view->history[i];
+
+				view->history[i].dir = NULL;
+				view->history[i].file = NULL;
+				view->history[i].rel_pos = -1;
+			}
+
+			if(view->history_pos == i)
+			{
+				view->history_pos = j;
+			}
+
+			++j;
+		}
+		view->history_num = j;
+	}
+
+	/* Reverse order in which items appear. */
+	for(i = 0; i < m.len/2; i++)
+	{
+		char *t = m.items[i];
+		m.items[i] = m.items[m.len - 1 - i];
+		m.items[m.len - 1 - i] = t;
+	}
+	m.pos = m.len - 1 - m.pos;
+
+	return display_menu(&m, view);
+}
+
+/* Callback that is called when menu item is selected.  Should return non-zero
+ * to stay in menu mode. */
+static int
+execute_dirhistory_cb(FileView *view, menu_info *m)
+{
+	goto_selected_directory(view, m->items[m->pos]);
+	return 0;
+}
+
+/* vim: set tabstop=2 softtabstop=2 shiftwidth=2 noexpandtab cinoptions-=(0 : */
+/* vim: set cinoptions+=t0 filetype=c : */

pool/shard010/C/0138087_20090907-1.c

@@ -0,0 +1,84 @@
+struct platform_device;
+typedef unsigned long __kernel_size_t;
+typedef unsigned short __u16;
+typedef unsigned int __u32;
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef __kernel_size_t size_t;
+typedef __u32 uint32_t;
+static inline __attribute__ ((always_inline))
+uint32_t __attribute__ ((pure)) bfin_dspid (void)
+{
+    return ( {
+	    uint32_t __v; __v;}
+    );
+}
+struct list_head {
+    struct list_head *next, *prev;
+};
+struct page {
+    union {
+    };
+    struct list_head lru;
+};
+struct device_driver {
+    const char *name;
+    struct module *owner;
+};
+struct fb_info {
+    struct device *dev;
+};
+struct platform_driver {
+    int (*probe) (struct platform_device *);
+    int (*remove) (struct platform_device *);
+    struct device_driver driver;
+};
+struct firmware {
+    size_t size;
+    const u8 *data;
+};
+struct metronomefb_par {
+    struct fb_info *info;
+};
+struct waveform_hdr {
+    u8 trc;
+};
+static u8 calc_cksum (int start, int end, u8 * mem)
+{
+    u8 tmp = 0;
+    int i;
+    for (i = start; i < end; i++)
+	tmp += mem[i];
+    return tmp;
+}
+extern struct waveform_hdr *wfm_hdr;
+extern int wmta;
+
+static int
+load_waveform (u8 * mem, size_t size, int m, int t, struct metronomefb_par *par)
+{
+    int tta;
+    int trn = 0;
+    int i;
+    u8 cksum;
+    int cksum_idx;
+    struct device *dev = par->info->dev;
+    for (i = 0; i <= sizeof (*wfm_hdr) + wfm_hdr->trc; i++) {
+	if (mem[i] > t) {
+	    trn = i - sizeof (*wfm_hdr) - 1;
+	}
+    }
+    tta = * (mem + wmta + m * 4) & 0x00FFFFFF;
+    cksum_idx = tta + trn * 4 + 3;
+    cksum = calc_cksum (cksum_idx - 3, cksum_idx, mem);
+    if (cksum != mem[cksum_idx]) {
+	abort();
+    }
+}
+extern struct firmware *fw_entry;
+extern struct metronomefb_par *par;
+
+int metronomefb_probe (struct platform_device *dev)
+{
+	return load_waveform ((u8 *) fw_entry->data, fw_entry->size, 3, 31, par);
+}

pool/shard010/C/0138088_msgrcv06.c

@@ -0,0 +1,219 @@
+/*
+ *
+ *   Copyright (c) International Business Machines  Corp., 2001
+ *
+ *   This program is free software;  you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+ *   the GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program;  if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * NAME
+ *	msgrcv06.c
+ *
+ * DESCRIPTION
+ *	msgrcv06 - test for EIDRM error
+ *
+ * ALGORITHM
+ *	loop if that option was specified
+ *	create a message queue with read/write permissions
+ *	fork a child who sleeps on an attempted read with msgrcv()
+ *	parent removes the queue then waits for child to complete
+ *	check the errno value
+ *	  issue a PASS message if we get EIDRM
+ *	otherwise, the tests fails
+ *	  issue a FAIL message
+ *      child removes message queue if required
+ *	parent callc cleanup
+ *
+ * USAGE:  <for command-line>
+ *  msgrcv06 [-c n] [-e] [-i n] [-I x] [-P x] [-t]
+ *     where,  -c n : Run n copies concurrently.
+ *             -e   : Turn on errno logging.
+ *	       -i n : Execute test n times.
+ *	       -I x : Execute test for x seconds.
+ *	       -P x : Pause for x seconds between iterations.
+ *	       -t   : Turn on syscall timing.
+ *
+ * HISTORY
+ *	03/2001 - Written by Wayne Boyer
+ *      14/03/2008 Matthieu Fertré (Matthieu.Fertre@irisa.fr)
+ *      - Fix concurrency issue. Due to the use of usleep function to
+ *        synchronize processes, synchronization issues can occur on a loaded
+ *        system. Fix this by using pipes to synchronize processes.
+ *
+ *
+ * RESTRICTIONS
+ *	none
+ */
+
+#include "test.h"
+
+#include "ipcmsg.h"
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+void do_child(void);
+void cleanup(void);
+void setup(void);
+#ifdef UCLINUX
+#define PIPE_NAME	"msgrcv06"
+void do_child_uclinux(void);
+#endif
+
+char *TCID = "msgrcv06";
+int TST_TOTAL = 1;
+
+int msg_q_1 = -1;		/* The message queue id created in setup */
+
+MSGBUF rcv_buf;
+pid_t c_pid;
+
+int main(int ac, char **av)
+{
+	int lc;
+
+	tst_parse_opts(ac, av, NULL, NULL);
+
+#ifdef UCLINUX
+	maybe_run_child(&do_child_uclinux, "d", &msg_q_1);
+#endif
+
+	setup();		/* global setup */
+
+	/* The following loop checks looping state if -i option given */
+
+	for (lc = 0; TEST_LOOPING(lc); lc++) {
+		/* reset tst_count in case we are looping */
+		tst_count = 0;
+
+		/*
+		 * set up the queue here so that multiple test iterations
+		 * will work.
+		 */
+		msgkey = getipckey();
+
+		/* create a message queue with read/write permission */
+		if ((msg_q_1 = msgget(msgkey, IPC_CREAT | IPC_EXCL | MSG_RW))
+		    == -1) {
+			tst_brkm(TBROK, cleanup, "Can't create message queue");
+		}
+
+		/*
+		 * fork a child that will attempt to read a non-existent
+		 * message from the queue
+		 */
+		if ((c_pid = FORK_OR_VFORK()) == -1) {
+			tst_brkm(TBROK, cleanup, "could not fork");
+		}
+
+		if (c_pid == 0) {	/* child */
+			/*
+			 * Attempt to read a message without IPC_NOWAIT.
+			 * With no message to read, the child sleeps.
+			 */
+
+#ifdef UCLINUX
+			if (self_exec(av[0], "d", msg_q_1) < 0) {
+				tst_brkm(TBROK, cleanup, "could not self_exec");
+			}
+#else
+			do_child();
+#endif
+		} else {
+			TST_PROCESS_STATE_WAIT(cleanup, c_pid, 'S');
+
+			/* remove the queue */
+			rm_queue(msg_q_1);
+
+			waitpid(c_pid, NULL, 0);
+		}
+	}
+
+	tst_exit();
+}
+
+/*
+ * do_child()
+ */
+void do_child(void)
+{
+	TEST(msgrcv(msg_q_1, &rcv_buf, MSGSIZE, 1, 0));
+
+	if (TEST_RETURN != -1) {
+		tst_resm(TFAIL, "call succeeded when error expected");
+		exit(-1);
+	}
+
+	switch (TEST_ERRNO) {
+	case EIDRM:
+		tst_resm(TPASS, "expected failure - errno = %d : %s",
+			 TEST_ERRNO, strerror(TEST_ERRNO));
+
+		/* mark the queue as invalid as it was removed */
+		msg_q_1 = -1;
+		break;
+	default:
+		tst_resm(TFAIL,
+			 "call failed with an unexpected error - %d : %s",
+			 TEST_ERRNO, strerror(TEST_ERRNO));
+		break;
+	}
+
+	/* if it exists, remove the message queue that was created */
+	rm_queue(msg_q_1);
+
+	exit(0);
+}
+
+#ifdef UCLINUX
+/*
+ * do_child_uclinux() - capture signals again, then run do_child()
+ */
+void do_child_uclinux(void)
+{
+	tst_sig(FORK, SIG_IGN, cleanup);
+
+	do_child();
+}
+#endif
+
+/*
+ * setup() - performs all the ONE TIME setup for this test.
+ */
+void setup(void)
+{
+
+	tst_sig(FORK, SIG_IGN, cleanup);
+
+	TEST_PAUSE;
+
+	/*
+	 * Create a temporary directory and cd into it.
+	 * This helps to ensure that a unique msgkey is created.
+	 * See libs/libltpipc/libipc.c for more information.
+	 */
+	tst_tmpdir();
+}
+
+/*
+ * cleanup() - performs all the ONE TIME cleanup for this test at completion
+ * 	       or premature exit.
+ */
+void cleanup(void)
+{
+
+	tst_rmdir();
+
+}

pool/shard010/C/0138089_CWE134_Uncontrolled_Format_String__char_console_vprintf_34.c

@@ -0,0 +1,193 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE134_Uncontrolled_Format_String__char_console_vprintf_34.c
+Label Definition File: CWE134_Uncontrolled_Format_String.vasinks.label.xml
+Template File: sources-vasinks-34.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 134 Uncontrolled Format String
+ * BadSource: console Read input from the console
+ * GoodSource: Copy a fixed string into data
+ * Sinks: vprintf
+ *    GoodSink: vprintf with a format string
+ *    BadSink : vprintf without a format string
+ * Flow Variant: 34 Data flow: use of a union containing two methods of accessing the same data (within the same function)
+ *
+ * */
+
+#include <stdarg.h>
+#include "std_testcase.h"
+
+#ifndef _WIN32
+#include <wchar.h>
+#endif
+
+typedef union
+{
+    char * unionFirst;
+    char * unionSecond;
+} CWE134_Uncontrolled_Format_String__char_console_vprintf_34_unionType;
+
+#ifndef OMITBAD
+
+static void badVaSink(char * data, ...)
+{
+    {
+        va_list args;
+        va_start(args, data);
+        /* POTENTIAL FLAW: Do not specify the format allowing a possible format string vulnerability */
+        vprintf(data, args);
+        va_end(args);
+    }
+}
+
+void CWE134_Uncontrolled_Format_String__char_console_vprintf_34_bad()
+{
+    char * data;
+    char dataBuffer[100] = "";
+    data = dataBuffer;
+    {
+        /* Read input from the console */
+        size_t dataLen = strlen(data);
+        /* if there is room in data, read into it from the console */
+        if (100-dataLen > 1)
+        {
+            /* POTENTIAL FLAW: Read data from the console */
+            if (fgets(data+dataLen, (int)(100-dataLen), stdin) != NULL)
+            {
+                /* The next few lines remove the carriage return from the string that is
+                 * inserted by fgets() */
+                dataLen = strlen(data);
+                if (dataLen > 0 && data[dataLen-1] == '\n')
+                {
+                    data[dataLen-1] = '\0';
+                }
+            }
+            else
+            {
+                printLine("fgets() failed");
+                /* Restore NUL terminator if fgets fails */
+                data[dataLen] = '\0';
+            }
+        }
+    }
+    {
+        char * dataCopy = data;
+        char * data = dataCopy;
+        badVaSink(data, data);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B uses the GoodSource with the BadSink */
+static void goodG2BVaSink(char * data, ...)
+{
+    {
+        va_list args;
+        va_start(args, data);
+        /* POTENTIAL FLAW: Do not specify the format allowing a possible format string vulnerability */
+        vprintf(data, args);
+        va_end(args);
+    }
+}
+
+static void goodG2B()
+{
+    char * data;
+    CWE134_Uncontrolled_Format_String__char_console_vprintf_34_unionType myUnion;
+    char dataBuffer[100] = "";
+    data = dataBuffer;
+    /* FIX: Use a fixed string that does not contain a format specifier */
+    strcpy(data, "fixedstringtest");
+    myUnion.unionFirst = data;
+    {
+        char * data = myUnion.unionSecond;
+        goodG2BVaSink(data, data);
+    }
+}
+
+/* goodB2G uses the BadSource with the GoodSink */
+static void goodB2GVaSink(char * data, ...)
+{
+    {
+        va_list args;
+        va_start(args, data);
+        /* FIX: Specify the format disallowing a format string vulnerability */
+        vprintf("%s", args);
+        va_end(args);
+    }
+}
+
+static void goodB2G()
+{
+    char * data;
+    CWE134_Uncontrolled_Format_String__char_console_vprintf_34_unionType myUnion;
+    char dataBuffer[100] = "";
+    data = dataBuffer;
+    {
+        /* Read input from the console */
+        size_t dataLen = strlen(data);
+        /* if there is room in data, read into it from the console */
+        if (100-dataLen > 1)
+        {
+            /* POTENTIAL FLAW: Read data from the console */
+            if (fgets(data+dataLen, (int)(100-dataLen), stdin) != NULL)
+            {
+                /* The next few lines remove the carriage return from the string that is
+                 * inserted by fgets() */
+                dataLen = strlen(data);
+                if (dataLen > 0 && data[dataLen-1] == '\n')
+                {
+                    data[dataLen-1] = '\0';
+                }
+            }
+            else
+            {
+                printLine("fgets() failed");
+                /* Restore NUL terminator if fgets fails */
+                data[dataLen] = '\0';
+            }
+        }
+    }
+    myUnion.unionFirst = data;
+    {
+        char * data = myUnion.unionSecond;
+        goodB2GVaSink(data, data);
+    }
+}
+
+void CWE134_Uncontrolled_Format_String__char_console_vprintf_34_good()
+{
+    goodG2B();
+    goodB2G();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE134_Uncontrolled_Format_String__char_console_vprintf_34_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE134_Uncontrolled_Format_String__char_console_vprintf_34_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif

pool/shard010/C/0138090_Descriptors.c

@@ -0,0 +1,264 @@
+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2011.
+
+  dean [at] fourwalledcubicle [dot] com
+           www.lufa-lib.org
+*/
+
+/*
+  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special
+ *  computer-readable structures which the host requests upon device enumeration, to determine
+ *  the device's capabilities and functions.
+ */
+
+#include "Descriptors.h"
+
+/** Device descriptor structure. This descriptor, located in SRAM memory, describes the overall
+ *  device characteristics, including the supported USB version, control endpoint size and the
+ *  number of device configurations. The descriptor is read out by the USB host when the enumeration
+ *  process begins.
+ */
+const USB_Descriptor_Device_t DeviceDescriptor =
+{
+	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
+
+	.USBSpecification       = VERSION_BCD(01.10),
+	.Class                  = CDC_CSCP_CDCClass,
+	.SubClass               = CDC_CSCP_NoSpecificSubclass,
+	.Protocol               = CDC_CSCP_NoSpecificProtocol,
+
+	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
+
+	.VendorID               = DEVICE_VID,
+	.ProductID              = DEVICE_PID,
+	.ReleaseNumber          = VERSION_BCD(00.01),
+
+	.ManufacturerStrIndex   = 0x02,
+	.ProductStrIndex        = 0x01,
+	.SerialNumStrIndex      = NO_DESCRIPTOR,
+
+	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
+};
+
+/** Configuration descriptor structure. This descriptor, located in SRAM memory, describes the usage
+ *  of the device in one of its supported configurations, including information about any device interfaces
+ *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
+ *  a configuration so that the host may correctly communicate with the USB device.
+ */
+const USB_Descriptor_Configuration_t ConfigurationDescriptor =
+{
+	.Config =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
+
+			.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
+			.TotalInterfaces        = 2,
+
+			.ConfigurationNumber    = 1,
+			.ConfigurationStrIndex  = NO_DESCRIPTOR,
+
+			.ConfigAttributes       = USB_CONFIG_ATTR_BUSPOWERED,
+
+			.MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
+		},
+
+	.CDC_CCI_Interface =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+			.InterfaceNumber        = 0,
+			.AlternateSetting       = 0,
+
+			.TotalEndpoints         = 1,
+
+			.Class                  = CDC_CSCP_CDCClass,
+			.SubClass               = CDC_CSCP_ACMSubclass,
+			.Protocol               = CDC_CSCP_ATCommandProtocol,
+
+			.InterfaceStrIndex      = NO_DESCRIPTOR
+		},
+
+	.CDC_Functional_Header =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalHeader_t), .Type = DTYPE_CSInterface},
+			.Subtype                = 0x00,
+
+			.CDCSpecification       = VERSION_BCD(01.10),
+		},
+
+	.CDC_Functional_ACM =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalACM_t), .Type = DTYPE_CSInterface},
+			.Subtype                = 0x02,
+
+			.Capabilities           = 0x04,
+		},
+
+	.CDC_Functional_Union =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalUnion_t), .Type = DTYPE_CSInterface},
+			.Subtype                = 0x06,
+
+			.MasterInterfaceNumber  = 0,
+			.SlaveInterfaceNumber   = 1,
+		},
+
+	.CDC_NotificationEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_IN | CDC_NOTIFICATION_EPNUM),
+			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_NOTIFICATION_EPSIZE,
+			.PollingIntervalMS      = 0xFF
+		},
+
+	.CDC_DCI_Interface =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+			.InterfaceNumber        = 1,
+			.AlternateSetting       = 0,
+
+			.TotalEndpoints         = 2,
+
+			.Class                  = CDC_CSCP_CDCDataClass,
+			.SubClass               = CDC_CSCP_NoDataSubclass,
+			.Protocol               = CDC_CSCP_NoDataProtocol,
+
+			.InterfaceStrIndex      = NO_DESCRIPTOR
+		},
+
+	.CDC_DataOutEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_OUT | CDC_RX_EPNUM),
+			.Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_TXRX_EPSIZE,
+			.PollingIntervalMS      = 0x01
+		},
+
+	.CDC_DataInEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_IN | CDC_TX_EPNUM),
+			.Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_TXRX_EPSIZE,
+			.PollingIntervalMS      = 0x01
+		}
+};
+
+/** Language descriptor structure. This descriptor, located in SRAM memory, is returned when the host requests
+ *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
+ *  via the language ID table available at USB.org what languages the device supports for its string descriptors.
+ */
+const USB_Descriptor_String_t LanguageString =
+{
+	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
+
+	.UnicodeString          = {LANGUAGE_ID_ENG}
+};
+
+/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
+ *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
+ *  Descriptor.
+ */
+const USB_Descriptor_String_t ProductString =
+{
+	.Header                 = {.Size = USB_STRING_LEN(16), .Type = DTYPE_String},
+
+	#if DEVICE_PID == 0x0036
+	//.UnicodeString          = L"Arduino Leonardo" 
+	.UnicodeString          = L"Helios Gadget" 
+	#else
+	.UnicodeString			= L"USB IO board    "
+	#endif
+};
+
+const USB_Descriptor_String_t ManufNameString = 
+{
+	.Header					= {.Size = USB_STRING_LEN(16), .Type = DTYPE_String},
+	
+	#if DEVICE_VID == 0x2341
+	//.UnicodeString			= L"Arduino LLC"
+	.UnicodeString			= L"KITT Engineering"
+	#else
+	.UnicodeString			= L"Unknown    "
+	#endif
+};
+
+/** This function is called by the library when in device mode, and must be overridden (see LUFA library "USB Descriptors"
+ *  documentation) by the application code so that the address and size of a requested descriptor can be given
+ *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
+ *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
+ *  USB host.
+ */
+uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
+                                    const uint8_t wIndex,
+                                    const void** const DescriptorAddress)
+{
+	const uint8_t  DescriptorType   = (wValue >> 8);
+	const uint8_t  DescriptorNumber = (wValue & 0xFF);
+
+	const void* Address = NULL;
+	uint16_t    Size    = NO_DESCRIPTOR;
+
+	switch (DescriptorType)
+	{
+		case DTYPE_Device:
+			Address = &DeviceDescriptor;
+			Size    = sizeof(USB_Descriptor_Device_t);
+			break;
+		case DTYPE_Configuration:
+			Address = &ConfigurationDescriptor;
+			Size    = sizeof(USB_Descriptor_Configuration_t);
+			break;
+		case DTYPE_String:
+			if (!(DescriptorNumber))
+			{
+				Address = &LanguageString;
+				Size    = LanguageString.Header.Size;
+			}
+			else if (DescriptorNumber == DeviceDescriptor.ProductStrIndex) 
+			{
+				Address = &ProductString;
+				Size    = ProductString.Header.Size;
+			} else if (DescriptorNumber == DeviceDescriptor.ManufacturerStrIndex)
+			{
+				Address = &ManufNameString;
+				Size	= ManufNameString.Header.Size;
+			}
+
+			break;
+	}
+
+	*DescriptorAddress = Address;
+	return Size;
+}
+

pool/shard010/C/0138091_ipa-pta-14.c

@@ -0,0 +1,32 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -fipa-pta -fno-tree-fre -fno-tree-sra -fdump-ipa-pta-details" } */
+
+struct X {
+    int i;
+    void *p;
+};
+
+static void * __attribute__((noinline,noclone))
+foo(struct X *q, void *p)
+{
+  struct X b;
+  b.p = p;
+  *q = b;
+  return q->p;
+}
+extern void abort (void);
+int main()
+{
+  struct X a, c;
+  void *p;
+  a.p = (void *)&c;
+  p = foo(&a, &a);
+  /* { dg-final { scan-ipa-dump "foo.result = { NULL a\[^ \]* c\[^ \]* }" "pta" { target { ! keeps_null_pointer_checks } } } } */
+  /* { dg-final { scan-ipa-dump "foo.result = { NONLOCAL a\[^ \]* c\[^ \]* }" "pta" { target { keeps_null_pointer_checks } } } } */
+  ((struct X *)p)->p = (void *)0;
+  if (a.p != (void *)0)
+    abort ();
+  return 0;
+}
+
+/* { dg-final { cleanup-ipa-dump "pta" } } */

pool/shard010/C/0138092_darken_x11.c

@@ -0,0 +1,54 @@
+/*
+    Copyright (c) 2013, Lukas Holecek <hluk@email.cz>
+
+    This file is part of TheRed.
+
+    TheRed is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    TheRed is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TheRed.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "darken.h"
+
+#include <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/xf86vmode.h>
+
+int darken(int r, int g, int b)
+{
+    int retval = -1;
+    int sz, i;
+    unsigned short *red, *green, *blue;
+
+    Display *dpy = XOpenDisplay(NULL);
+    if (dpy == NULL)
+        return -1;
+
+    XF86VidModeGetGammaRampSize(dpy, 0, &sz);
+
+    red = malloc(sz * sizeof(unsigned short));
+    green = malloc(sz * sizeof(unsigned short));
+    blue = malloc(sz * sizeof(unsigned short));
+
+    XF86VidModeGetGammaRamp(dpy, 0, sz, red, green, blue);
+
+    retval = change_colors(red, green, blue, sz, r, g, b);
+
+    XF86VidModeSetGammaRamp(dpy, 0, sz, red, green, blue);
+
+    free(red);
+    free(green);
+    free(blue);
+    XCloseDisplay(dpy);
+
+    return retval;
+}

pool/shard010/C/0138093_pseudo_wrappers.c

@@ -0,0 +1,229 @@
+/* shared functionality for the xattr code */
+/* Each of these functions is expecting to get an optional name, and
+ * a populated statbuf to use for sending messages to the server.
+ */
+
+/* to avoid namespace pollution and such, we now duplicate the
+ * basic functionality of a POSIX ACL list, as used by libacl or
+ * the kernel. Documentation was obtained from the headers of libacl
+ * and from a page or two of _The Linux Programming Interface_, by
+ * Michael Kerrisk.
+ */
+
+typedef struct {
+	uint16_t tag;
+	uint16_t perm;
+	uint32_t id;
+} acl_entry;
+
+typedef struct {
+	uint32_t version;
+	acl_entry entries[];
+} acl_header;
+
+enum acl_tags {
+	ACL_UNDEFINED = 0x0,
+	ACL_USER_OBJ = 0x1,
+	ACL_USER = 0x2,
+	ACL_GROUP_OBJ = 0x4,
+	ACL_GROUP = 0x8,
+	ACL_MASK = 0x10,
+	ACL_OTHER = 0x20,
+};
+
+static const int endian_test = 1;
+static const char *endian_tester = (char *) &endian_test;
+
+static inline int
+le16(int x16) {
+	if (*endian_tester) {
+		return x16;
+	} else {
+		return ((x16 & 0xff) << 8) | ((x16 & 0xff00) >> 8);
+	}
+}
+
+static inline int
+le32(int x32) {
+	if (*endian_tester) {
+		return x32;
+	} else {
+		return ((x32 & 0xff) << 24) | ((x32 & 0xff00) << 8) |
+		       ((x32 & 0xff0000) >> 8) | ((x32 & 0xff000000) >> 24);
+	}
+}
+
+/* set mode to match the contents of header. Return non-zero on error.
+ * On a zero return, mode is a valid posix mode, and *extra is set to
+ * 1 if any of the entries are not reflected by that mode. On a non-zero
+ * return, no promises are made about *extra or *mode.
+ */
+static int
+posix_permissions(const acl_header *header, int entries, int *extra, int *mode) {
+	int acl_seen = 0;
+	if (le32(header->version) != 2) {
+		pseudo_diag("Fatal: ACL support no available for header version %d.\n",
+			le32(header->version));
+		return 1;
+	}
+	*mode = 0;
+	*extra = 0;
+	for (int i = 0; i < entries; ++i) {
+		const acl_entry *e = &header->entries[i];
+		int tag = le16(e->tag);
+		int perm = le16(e->perm);
+		acl_seen |= tag;
+		switch (tag) {
+		case ACL_USER_OBJ:
+			*mode = *mode | (perm << 6);
+			break;
+		case ACL_GROUP_OBJ:
+			*mode = *mode | (perm << 3);
+			break;
+		case ACL_OTHER:
+			*mode = *mode | perm;
+			break;
+		case ACL_USER:
+		case ACL_GROUP:
+		case ACL_MASK:
+			*extra = *extra + 1;
+			break;
+		default:
+			pseudo_debug(PDBGF_XATTR, "Unknown tag in ACL: 0x%x.\n",
+				tag);
+			return 1;
+		}
+	}
+	return 0;
+}
+
+#define RC_AND_BUF \
+	int rc; \
+	PSEUDO_STATBUF buf; \
+	if (path) { \
+		rc = base_lstat(path, &buf); \
+	} else { \
+		rc = base_fstat(fd, &buf); \
+	} \
+	if (rc == -1) { \
+		return rc; \
+	}
+	
+static ssize_t shared_getxattr(const char *path, int fd, const char *name, void *value, size_t size) {
+	RC_AND_BUF
+
+	pseudo_debug(PDBGF_XATTR, "getxattr(%s [fd %d], %s)\n",
+		path ? path : "<no path>", fd, name);
+	pseudo_msg_t *result = pseudo_client_op(OP_GET_XATTR, 0, fd, -1, path, &buf, name);
+	if (result->result != RESULT_SUCCEED) {
+		errno = ENOATTR;
+		return -1;
+	}
+
+	if (value) {
+		pseudo_debug(PDBGF_XATTR, "returned attributes: '%s' (%d bytes)\n",
+			result->path, result->pathlen);
+		if (size >= result->pathlen) {
+			memcpy(value, result->path, result->pathlen);
+		} else {
+			memcpy(value, result->path, size);
+			errno = ERANGE;
+		}
+	}
+	return result->pathlen;
+}
+
+static int shared_setxattr(const char *path, int fd, const char *name, const void *value, size_t size, int flags) {
+	RC_AND_BUF
+	pseudo_op_t op;
+
+	pseudo_debug(PDBGF_XATTR, "setxattr(%s [fd %d], %s => '%.*s')\n",
+		path ? path : "<no path>", fd, name, (int) size, (char *) value);
+
+	/* this may be a plain chmod */
+	if (!strcmp(name, "system.posix_acl_access")) {
+		int extra;
+		int mode;
+		int entries = (size - sizeof(acl_header)) / sizeof(acl_entry);
+		if (!posix_permissions(value, entries, &extra, &mode)) {
+			pseudo_debug(PDBGF_XATTR, "posix_acl_access translated to mode %04o. Remaining attribute(s): %d.\n",
+				mode, extra);
+			buf.st_mode = mode;
+			/* we want to actually issue a corresponding chmod,
+			 * as well, or else the file ends up 0600 on the
+			 * host. Using the slightly-less-efficient wrap_chmod
+			 * avoids possible misalignment.
+			 */
+			if (path) {
+				wrap_chmod(path, mode);
+			} else {
+				wrap_fchmod(fd, mode);
+			}
+			/* we are sneaky, and do not actually record this using
+			 * extended attributes. */
+			if (!extra) {
+				return 0;
+			}
+		}
+	}
+
+	switch (flags) {
+	case XATTR_CREATE:
+		op = OP_CREATE_XATTR;
+		break;
+	case XATTR_REPLACE:
+		op = OP_REPLACE_XATTR;
+		break;
+	default:
+		op = OP_SET_XATTR;
+		break;
+	}
+
+	pseudo_msg_t *result = pseudo_client_op(op, 0, fd, -1, path, &buf, name, value, size);
+	
+	/* we automatically assume success */
+	if (op == OP_SET_XATTR) {
+		return 0;
+	}
+
+	/* CREATE/REPLACE operations can report failure */
+	if (!result || result->result == RESULT_FAIL) {
+		return -1;
+	}
+
+	return 0;
+}
+
+static ssize_t shared_listxattr(const char *path, int fd, char *list, size_t size) {
+	RC_AND_BUF
+	pseudo_msg_t *result = pseudo_client_op(OP_LIST_XATTR, 0, fd, -1, path, &buf);
+	if (result->result != RESULT_SUCCEED) {
+		pseudo_debug(PDBGF_XATTR, "listxattr: no success.\n");
+		errno = ENOATTR;
+		return -1;
+	}
+	if (list) {
+		pseudo_debug(PDBGF_XATTR, "listxattr: %d bytes of names, starting '%.*s'\n",
+			(int) result->pathlen, (int) result->pathlen, result->path);
+		if (size >= result->pathlen) {
+			memcpy(list, result->path, result->pathlen);
+		} else {
+			memcpy(list, result->path, size);
+			errno = ERANGE;
+		}
+	}
+	return result->pathlen;
+}
+
+static int shared_removexattr(const char *path, int fd, const char *name) {
+	RC_AND_BUF
+	pseudo_msg_t *result = pseudo_client_op(OP_REMOVE_XATTR, 0, fd, -1, path, &buf, name);
+
+	if (result->result != RESULT_SUCCEED) {
+		/* docs say ENOATTR, but I don't have one */
+		errno = ENOENT;
+		return -1;
+	}
+	return 0;
+}
+

pool/shard010/C/0138094_restart_7k.c

@@ -0,0 +1,103 @@
+/* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/reboot.h>
+#include <linux/pm.h>
+#include <asm/system_misc.h>
+#include <mach/proc_comm.h>
+
+#include "devices-msm7x2xa.h"
+
+static uint32_t restart_reason = 0x776655AA;
+
+static void msm_pm_power_off(void)
+{
+	msm_proc_comm(PCOM_POWER_DOWN, 0, 0);
+	for (;;)
+		;
+}
+
+static void msm_pm_restart(char str, const char *cmd)
+{
+	pr_debug("The reset reason is %x\n", restart_reason);
+
+	/* Disable interrupts */
+	local_irq_disable();
+	local_fiq_disable();
+
+	/*
+	 * Take out a flat memory mapping  and will
+	 * insert a 1:1 mapping in place of
+	 * the user-mode pages to ensure predictable results
+	 * This function takes care of flushing the caches
+	 * and flushing the TLB.
+	 */
+	setup_mm_for_reboot();
+
+	msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0);
+
+	for (;;)
+		;
+}
+
+static int msm_reboot_call
+	(struct notifier_block *this, unsigned long code, void *_cmd)
+{
+	if ((code == SYS_RESTART) && _cmd) {
+		char *cmd = _cmd;
+		if (!strncmp(cmd, "bootloader", 10)) {
+			restart_reason = 0x77665500;
+		} else if (!strncmp(cmd, "recovery", 8)) {
+			restart_reason = 0x77665502;
+		} else if (!strncmp(cmd, "eraseflash", 10)) {
+			restart_reason = 0x776655EF;
+		} else if (!strncmp(cmd, "oem-", 4)) {
+			unsigned long code;
+			int res;
+			res = kstrtoul(cmd + 4, 16, &code);
+			code &= 0xff;
+			restart_reason = 0x6f656d00 | code;
+#ifdef CONFIG_HUAWEI_KERNEL
+		} else if (!strcmp(cmd, "mtkupdate")) {
+#define MTK_DOWNLOAD_EN 0x6d74646c
+			restart_reason = MTK_DOWNLOAD_EN;
+#endif
+		} else {
+			restart_reason = 0x77665501;
+		}
+	}
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block msm_reboot_notifier = {
+	.notifier_call = msm_reboot_call,
+};
+
+static int __init msm_pm_restart_init(void)
+{
+	int ret;
+
+	pm_power_off = msm_pm_power_off;
+	arm_pm_restart = msm_pm_restart;
+
+	ret = register_reboot_notifier(&msm_reboot_notifier);
+	if (ret)
+		pr_err("Failed to register reboot notifier\n");
+
+	return ret;
+}
+late_initcall(msm_pm_restart_init);

pool/shard010/C/0138095_phy-exynos-mipi-video.c

@@ -0,0 +1,175 @@
+/*
+ * Samsung S5P/EXYNOS SoC series MIPI CSIS/DSIM DPHY driver
+ *
+ * Copyright (C) 2013 Samsung Electronics Co., Ltd.
+ * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+
+/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
+#define EXYNOS_MIPI_PHY_CONTROL(n)	((n) * 4)
+#define EXYNOS_MIPI_PHY_ENABLE		(1 << 0)
+#define EXYNOS_MIPI_PHY_SRESETN		(1 << 1)
+#define EXYNOS_MIPI_PHY_MRESETN		(1 << 2)
+#define EXYNOS_MIPI_PHY_RESET_MASK	(3 << 1)
+
+enum exynos_mipi_phy_id {
+	EXYNOS_MIPI_PHY_ID_CSIS0,
+	EXYNOS_MIPI_PHY_ID_DSIM0,
+	EXYNOS_MIPI_PHY_ID_CSIS1,
+	EXYNOS_MIPI_PHY_ID_DSIM1,
+	EXYNOS_MIPI_PHYS_NUM
+};
+
+#define is_mipi_dsim_phy_id(id) \
+	((id) == EXYNOS_MIPI_PHY_ID_DSIM0 || (id) == EXYNOS_MIPI_PHY_ID_DSIM1)
+
+struct exynos_mipi_video_phy {
+	spinlock_t slock;
+	struct video_phy_desc {
+		struct phy *phy;
+		unsigned int index;
+	} phys[EXYNOS_MIPI_PHYS_NUM];
+	void __iomem *regs;
+};
+
+static int __set_phy_state(struct exynos_mipi_video_phy *state,
+			enum exynos_mipi_phy_id id, unsigned int on)
+{
+	void __iomem *addr;
+	u32 reg, reset;
+
+	addr = state->regs + EXYNOS_MIPI_PHY_CONTROL(id / 2);
+
+	if (is_mipi_dsim_phy_id(id))
+		reset = EXYNOS_MIPI_PHY_MRESETN;
+	else
+		reset = EXYNOS_MIPI_PHY_SRESETN;
+
+	spin_lock(&state->slock);
+	reg = readl(addr);
+	if (on)
+		reg |= reset;
+	else
+		reg &= ~reset;
+	writel(reg, addr);
+
+	/* Clear ENABLE bit only if MRESETN, SRESETN bits are not set. */
+	if (on)
+		reg |= EXYNOS_MIPI_PHY_ENABLE;
+	else if (!(reg & EXYNOS_MIPI_PHY_RESET_MASK))
+		reg &= ~EXYNOS_MIPI_PHY_ENABLE;
+
+	writel(reg, addr);
+	spin_unlock(&state->slock);
+	return 0;
+}
+
+#define to_mipi_video_phy(desc) \
+	container_of((desc), struct exynos_mipi_video_phy, phys[(desc)->index]);
+
+static int exynos_mipi_video_phy_power_on(struct phy *phy)
+{
+	struct video_phy_desc *phy_desc = phy_get_drvdata(phy);
+	struct exynos_mipi_video_phy *state = to_mipi_video_phy(phy_desc);
+
+	return __set_phy_state(state, phy_desc->index, 1);
+}
+
+static int exynos_mipi_video_phy_power_off(struct phy *phy)
+{
+	struct video_phy_desc *phy_desc = phy_get_drvdata(phy);
+	struct exynos_mipi_video_phy *state = to_mipi_video_phy(phy_desc);
+
+	return __set_phy_state(state, phy_desc->index, 0);
+}
+
+static struct phy *exynos_mipi_video_phy_xlate(struct device *dev,
+					struct of_phandle_args *args)
+{
+	struct exynos_mipi_video_phy *state = dev_get_drvdata(dev);
+
+	if (WARN_ON(args->args[0] >= EXYNOS_MIPI_PHYS_NUM))
+		return ERR_PTR(-ENODEV);
+
+	return state->phys[args->args[0]].phy;
+}
+
+static struct phy_ops exynos_mipi_video_phy_ops = {
+	.power_on	= exynos_mipi_video_phy_power_on,
+	.power_off	= exynos_mipi_video_phy_power_off,
+	.owner		= THIS_MODULE,
+};
+
+static int exynos_mipi_video_phy_probe(struct platform_device *pdev)
+{
+	struct exynos_mipi_video_phy *state;
+	struct device *dev = &pdev->dev;
+	struct resource *res;
+	struct phy_provider *phy_provider;
+	unsigned int i;
+
+	state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
+	if (!state)
+		return -ENOMEM;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+	state->regs = devm_ioremap_resource(dev, res);
+	if (IS_ERR(state->regs))
+		return PTR_ERR(state->regs);
+
+	dev_set_drvdata(dev, state);
+	spin_lock_init(&state->slock);
+
+	for (i = 0; i < EXYNOS_MIPI_PHYS_NUM; i++) {
+		struct phy *phy = devm_phy_create(dev, NULL,
+					&exynos_mipi_video_phy_ops, NULL);
+		if (IS_ERR(phy)) {
+			dev_err(dev, "failed to create PHY %d\n", i);
+			return PTR_ERR(phy);
+		}
+
+		state->phys[i].phy = phy;
+		state->phys[i].index = i;
+		phy_set_drvdata(phy, &state->phys[i]);
+	}
+
+	phy_provider = devm_of_phy_provider_register(dev,
+					exynos_mipi_video_phy_xlate);
+
+	return PTR_ERR_OR_ZERO(phy_provider);
+}
+
+static const struct of_device_id exynos_mipi_video_phy_of_match[] = {
+	{ .compatible = "samsung,s5pv210-mipi-video-phy" },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, exynos_mipi_video_phy_of_match);
+
+static struct platform_driver exynos_mipi_video_phy_driver = {
+	.probe	= exynos_mipi_video_phy_probe,
+	.driver = {
+		.of_match_table	= exynos_mipi_video_phy_of_match,
+		.name  = "exynos-mipi-video-phy",
+		.owner = THIS_MODULE,
+	}
+};
+module_platform_driver(exynos_mipi_video_phy_driver);
+
+MODULE_DESCRIPTION("Samsung S5P/EXYNOS SoC MIPI CSI-2/DSI PHY driver");
+MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
+MODULE_LICENSE("GPL v2");

pool/shard010/C/0138096_kfd_device_queue_manager_vi.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2014 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "kfd_device_queue_manager.h"
+
+static bool set_cache_memory_policy_vi(struct device_queue_manager *dqm,
+				   struct qcm_process_device *qpd,
+				   enum cache_policy default_policy,
+				   enum cache_policy alternate_policy,
+				   void __user *alternate_aperture_base,
+				   uint64_t alternate_aperture_size);
+static int register_process_vi(struct device_queue_manager *dqm,
+					struct qcm_process_device *qpd);
+static int initialize_cpsch_vi(struct device_queue_manager *dqm);
+
+void device_queue_manager_init_vi(struct device_queue_manager_ops *ops)
+{
+	pr_warn("amdkfd: VI DQM is not currently supported\n");
+
+	ops->set_cache_memory_policy = set_cache_memory_policy_vi;
+	ops->register_process = register_process_vi;
+	ops->initialize = initialize_cpsch_vi;
+}
+
+static bool set_cache_memory_policy_vi(struct device_queue_manager *dqm,
+				   struct qcm_process_device *qpd,
+				   enum cache_policy default_policy,
+				   enum cache_policy alternate_policy,
+				   void __user *alternate_aperture_base,
+				   uint64_t alternate_aperture_size)
+{
+	return false;
+}
+
+static int register_process_vi(struct device_queue_manager *dqm,
+					struct qcm_process_device *qpd)
+{
+	return -1;
+}
+
+static int initialize_cpsch_vi(struct device_queue_manager *dqm)
+{
+	return 0;
+}

pool/shard010/C/0138097_SecPlatformInformation.c

@@ -0,0 +1,84 @@
+/** @file
+  Sample to provide SecPlatformInformation function.
+
+  Copyright (c) 2014, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php.
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include <PiPei.h>
+
+#include <Ppi/SecPlatformInformation.h>
+#include <Ppi/TopOfTemporaryRam.h>
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+
+/**
+  This interface conveys state information out of the Security (SEC) phase into PEI.
+
+  @param[in]     PeiServices               Pointer to the PEI Services Table.
+  @param[in,out] StructureSize             Pointer to the variable describing size of the input buffer.
+  @param[out]    PlatformInformationRecord Pointer to the EFI_SEC_PLATFORM_INFORMATION_RECORD.
+
+  @retval EFI_SUCCESS           The data was successfully returned.
+  @retval EFI_BUFFER_TOO_SMALL  The buffer was too small.
+
+**/
+EFI_STATUS
+EFIAPI
+SecPlatformInformation (
+  IN CONST EFI_PEI_SERVICES                     **PeiServices,
+  IN OUT   UINT64                               *StructureSize,
+     OUT   EFI_SEC_PLATFORM_INFORMATION_RECORD  *PlatformInformationRecord
+  )
+{
+  UINT32      *Bist;
+  UINT32      Size;
+  UINT32      Count;
+  UINT32      TopOfTemporaryRam;
+  VOID        *TopOfTemporaryRamPpi;
+  EFI_STATUS  Status;
+
+  DEBUG ((DEBUG_INFO, "SecPlatformInformation\n"));
+
+  Status = (*PeiServices)->LocatePpi (
+                             PeiServices,
+                             &gTopOfTemporaryRamPpiGuid,
+                             0,
+                             NULL,
+                             (VOID **) &TopOfTemporaryRamPpi
+                             );
+  if (EFI_ERROR (Status)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // The entries of BIST information, together with the number of them,
+  // reside in the bottom of stack, left untouched by normal stack operation.
+  // This routine copies the BIST information to the buffer pointed by
+  // PlatformInformationRecord for output.
+  //
+  TopOfTemporaryRam = (UINT32)(UINTN)TopOfTemporaryRamPpi - sizeof (UINT32);
+  TopOfTemporaryRam -= sizeof(UINT32) * 2;
+  Count             = *((UINT32 *)(UINTN) (TopOfTemporaryRam - sizeof (UINT32)));
+  Size              = Count * sizeof (IA32_HANDOFF_STATUS);
+
+  if ((*StructureSize) < (UINT64) Size) {
+    *StructureSize = Size;
+    return EFI_BUFFER_TOO_SMALL;
+  }
+
+  *StructureSize  = Size;
+  Bist            = (UINT32 *) (TopOfTemporaryRam - sizeof (UINT32) - Size);
+
+  CopyMem (PlatformInformationRecord, Bist, Size);
+
+  return EFI_SUCCESS;
+}

pool/shard010/C/0138098_basic.c

@@ -0,0 +1,24 @@
+#include <state.h>
+#include <stdio.h>
+
+int a(void *p){
+  static int counter=0;
+  counter+=1;
+  printf("a: %d\n",counter);
+  return counter;
+}
+
+int b(void *p){
+  printf("b\n");
+  return 0;
+}
+
+int main(){
+  struct StateMachine *machine;
+  machine=state_newmachine();
+  state_add_transition(machine,a,1,b);
+  state_add_transition(machine,b,0,a);
+  state_add_transition(machine,a,2,NULL);
+  state_start(machine,a,NULL);
+  state_free(machine);
+}

pool/shard010/C/0138099_platsmp.c

@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2002 ARM Ltd.
+ * Copyright (C) 2008 STMicroelctronics.
+ * Copyright (C) 2009 ST-Ericsson.
+ * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
+ *
+ * This file is based on arm realview platform
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/smp.h>
+#include <linux/io.h>
+
+#include <asm/cacheflush.h>
+#include <asm/hardware/gic.h>
+#include <asm/smp_plat.h>
+#include <asm/smp_scu.h>
+#include <mach/hardware.h>
+#include <mach/setup.h>
+
+/* This is called from headsmp.S to wakeup the secondary core */
+extern void u8500_secondary_startup(void);
+
+/*
+ * Write pen_release in a way that is guaranteed to be visible to all
+ * observers, irrespective of whether they're taking part in coherency
+ * or not.  This is necessary for the hotplug code to work reliably.
+ */
+static void write_pen_release(int val)
+{
+	pen_release = val;
+	smp_wmb();
+	__cpuc_flush_dcache_area((void *)&pen_release, sizeof(pen_release));
+	outer_clean_range(__pa(&pen_release), __pa(&pen_release + 1));
+}
+
+static void __iomem *scu_base_addr(void)
+{
+	if (cpu_is_u8500_family() || cpu_is_ux540_family())
+		return __io_address(U8500_SCU_BASE);
+	else
+		ux500_unknown_soc();
+
+	return NULL;
+}
+
+static DEFINE_SPINLOCK(boot_lock);
+
+static void __cpuinit ux500_secondary_init(unsigned int cpu)
+{
+	/*
+	 * if any interrupts are already enabled for the primary
+	 * core (e.g. timer irq), then they will not have been enabled
+	 * for us: do so
+	 */
+	gic_secondary_init(0);
+
+	/*
+	 * let the primary processor know we're out of the
+	 * pen, then head off into the C entry point
+	 */
+	write_pen_release(-1);
+
+	/*
+	 * Synchronise with the boot thread.
+	 */
+	spin_lock(&boot_lock);
+	spin_unlock(&boot_lock);
+}
+
+static int __cpuinit ux500_boot_secondary(unsigned int cpu, struct task_struct *idle)
+{
+	unsigned long timeout;
+
+	/*
+	 * set synchronisation state between this boot processor
+	 * and the secondary one
+	 */
+	spin_lock(&boot_lock);
+
+	/*
+	 * The secondary processor is waiting to be released from
+	 * the holding pen - release it, then wait for it to flag
+	 * that it has been released by resetting pen_release.
+	 */
+	write_pen_release(cpu_logical_map(cpu));
+
+	smp_send_reschedule(cpu);
+
+	timeout = jiffies + (1 * HZ);
+	while (time_before(jiffies, timeout)) {
+		if (pen_release == -1)
+			break;
+	}
+
+	/*
+	 * now the secondary core is starting up let it run its
+	 * calibrations, then wait for it to finish
+	 */
+	spin_unlock(&boot_lock);
+
+	return pen_release != -1 ? -ENOSYS : 0;
+}
+
+static void __init wakeup_secondary(void)
+{
+	void __iomem *backupram;
+
+	if (cpu_is_u8500_family() || cpu_is_ux540_family())
+		backupram = __io_address(U8500_BACKUPRAM0_BASE);
+	else
+		ux500_unknown_soc();
+
+	/*
+	 * write the address of secondary startup into the backup ram register
+	 * at offset 0x1FF4, then write the magic number 0xA1FEED01 to the
+	 * backup ram register at offset 0x1FF0, which is what boot rom code
+	 * is waiting for. This would wake up the secondary core from WFE
+	 */
+#define UX500_CPU1_JUMPADDR_OFFSET 0x1FF4
+	__raw_writel(virt_to_phys(u8500_secondary_startup),
+		     backupram + UX500_CPU1_JUMPADDR_OFFSET);
+
+#define UX500_CPU1_WAKEMAGIC_OFFSET 0x1FF0
+	__raw_writel(0xA1FEED01,
+		     backupram + UX500_CPU1_WAKEMAGIC_OFFSET);
+
+	/* make sure write buffer is drained */
+	mb();
+}
+
+/*
+ * Initialise the CPU possible map early - this describes the CPUs
+ * which may be present or become present in the system.
+ */
+static void __init ux500_smp_init_cpus(void)
+{
+	void __iomem *scu_base = scu_base_addr();
+	unsigned int i, ncores;
+
+	ncores = scu_base ? scu_get_core_count(scu_base) : 1;
+
+	/* sanity check */
+	if (ncores > nr_cpu_ids) {
+		pr_warn("SMP: %u cores greater than maximum (%u), clipping\n",
+			ncores, nr_cpu_ids);
+		ncores = nr_cpu_ids;
+	}
+
+	for (i = 0; i < ncores; i++)
+		set_cpu_possible(i, true);
+
+	set_smp_cross_call(gic_raise_softirq);
+}
+
+static void __init ux500_smp_prepare_cpus(unsigned int max_cpus)
+{
+
+	scu_enable(scu_base_addr());
+	wakeup_secondary();
+}
+
+struct smp_operations ux500_smp_ops __initdata = {
+	.smp_init_cpus		= ux500_smp_init_cpus,
+	.smp_prepare_cpus	= ux500_smp_prepare_cpus,
+	.smp_secondary_init	= ux500_secondary_init,
+	.smp_boot_secondary	= ux500_boot_secondary,
+#ifdef CONFIG_HOTPLUG_CPU
+	.cpu_die		= ux500_cpu_die,
+#endif
+};

pool/shard010/C/0138100_artst.c

@@ -0,0 +1,91 @@
+/* Quick hack to test input of non aligned data */
+/* Quickly hacked from atst */
+/* PAB 1/8/92 */
+
+#include <helios.h>
+
+#if 1			/* posix version */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <posix.h>
+#include <fcntl.h>
+
+int main(int argc, char **argv)
+{
+	int sz;
+	char *fred = "abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz";
+
+		/*    012345678901234567890123456789 */
+
+	int	fd = open("/helios/lib/nucleus", O_RDONLY);
+
+	for (sz = 1 ;sz <= 20; sz++) {
+		fprintf(stderr, "Read sz %d\n", sz);
+		read(fd, &fred[0], sz);
+#if 1
+		read(fd, &fred[1], sz);
+		read(fd, &fred[2], sz);
+		read(fd, &fred[3], sz);
+#endif
+	}
+}
+
+#else			/* syslib version */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <posix.h>
+#include <fcntl.h>
+#include <syslib.h>
+
+int main(int argc, char **argv)
+{
+	int sz;
+	char *fred = "abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz"
+			"abcdefghijklmnopqrstuvwxyz";
+
+		/*    012345678901234567890123456789 */
+
+	Object *ob = Locate(NULL, "/helios/lib/nucleus");
+	Stream *fd = Open(ob, NULL, O_ReadOnly);
+
+	for (sz = 1 ;sz <= 20; sz++) {
+		fprintf(stderr, "Read sz %d\n", sz);
+		Read(fd, &fred[0], sz, -1);
+#if 1
+		Read(fd, &fred[1], sz, -1);
+		Read(fd, &fred[2], sz, -1);
+		Read(fd, &fred[3], sz, -1);
+#endif
+	}
+}
+#endif
+
+
+/* end of align test */

pool/shard010/C/0138101_uart.c

@@ -0,0 +1,219 @@
+/*
+ * Include processor definitions.
+ */
+#include "pic32mz.h"
+
+#define MHZ     200             /* CPU clock. */
+
+/*
+ * Chip configuration.
+ */
+PIC32_DEVCFG (
+    DEVCFG0_JTAG_DISABLE |      /* Disable JTAG port */
+    DEVCFG0_TRC_DISABLE,        /* Disable trace port */
+#if 0
+    /* Case #1: using internal fast RC oscillator.
+     * The frequency is around 8 MHz.
+     * PLL multiplies it to 200 MHz. */
+    DEVCFG1_FNOSC_SPLL |        /* System clock supplied by SPLL */
+    DEVCFG1_POSCMOD_DISABLE |   /* Primary oscillator disabled */
+    DEVCFG1_CLKO_DISABLE,       /* CLKO output disable */
+
+    DEVCFG2_FPLLIDIV_1 |        /* PLL input divider = 1 */
+    DEVCFG2_FPLLRNG_5_10 |      /* PLL input range is 5-10 MHz */
+    DEVCFG2_FPLLICLK_FRC |      /* Select FRC as input to PLL */
+    DEVCFG2_FPLLMULT(50) |      /* PLL multiplier = 50x */
+    DEVCFG2_FPLLODIV_2,         /* PLL postscaler = 1/2 */
+#endif
+#if 1
+    /* Case #2: using primary oscillator with external crystal 24 MHz.
+     * PLL multiplies it to 200 MHz. */
+    DEVCFG1_FNOSC_SPLL |        /* System clock supplied by SPLL */
+    DEVCFG1_POSCMOD_EXT |       /* External generator */
+    DEVCFG1_FCKS_ENABLE |       /* Enable clock switching */
+    DEVCFG1_FCKM_ENABLE |       /* Enable fail-safe clock monitoring */
+    DEVCFG1_IESO |              /* Internal-external switch over enable */
+    DEVCFG1_CLKO_DISABLE,       /* CLKO output disable */
+
+    DEVCFG2_FPLLIDIV_3 |        /* PLL input divider = 3 */
+    DEVCFG2_FPLLRNG_5_10 |      /* PLL input range is 5-10 MHz */
+    DEVCFG2_FPLLMULT(50) |      /* PLL multiplier = 50x */
+    DEVCFG2_FPLLODIV_2,         /* PLL postscaler = 1/2 */
+#endif
+    DEVCFG3_FETHIO |            /* Default Ethernet pins */
+    DEVCFG3_USERID(0xffff));    /* User-defined ID */
+
+/*
+ * Boot code at bfc00000.
+ * Setup stack pointer and $gp registers, and jump to main().
+ */
+asm ("          .section .exception");
+asm ("          .globl _start");
+asm ("          .type _start, function");
+asm ("_start:   la      $sp, _estack");
+asm ("          la      $ra, main");
+asm ("          la      $gp, _gp");
+asm ("          jr      $ra");
+asm ("          .text");
+asm ("_estack   = _end + 0x1000");
+
+volatile unsigned loop;
+
+/*
+ * Delay for a given number of microseconds.
+ * The processor has a 32-bit hardware Count register,
+ * which increments at half CPU rate.
+ * We use it to get a precise delay.
+ */
+void udelay (unsigned usec)
+{
+    unsigned now = mfc0 (C0_COUNT, 0);
+    unsigned final = now + usec * MHZ / 2;
+
+    for (;;) {
+        now = mfc0 (C0_COUNT, 0);
+
+        /* This comparison is valid only when using a signed type. */
+        if ((int) (now - final) >= 0)
+            break;
+    }
+}
+
+/*
+ * Send a byte to the UART transmitter, with interrupts disabled.
+ */
+void putch (unsigned char c)
+{
+    /* Wait for transmitter shift register empty. */
+    while (! (U1STA & PIC32_USTA_TRMT))
+        continue;
+
+again:
+    /* Send byte. */
+    U1TXREG = c;
+
+    /* Wait for transmitter shift register empty. */
+    while (! (U1STA & PIC32_USTA_TRMT))
+        continue;
+
+    if (c == '\n') {
+        c = '\r';
+        goto again;
+    }
+}
+
+/*
+ * Wait for the byte to be received and return it.
+ */
+unsigned getch (void)
+{
+    unsigned c;
+
+    for (;;) {
+        /* Wait until receive data available. */
+        if (U1STA & PIC32_USTA_URXDA) {
+            c = (unsigned char) U1RXREG;
+            break;
+        }
+    }
+    return c;
+}
+
+int hexchar (unsigned val)
+{
+    return "0123456789abcdef" [val & 0xf];
+}
+
+void printreg (const char *p, unsigned val)
+{
+    for (; *p; ++p)
+        putch (*p);
+
+    putch ('=');
+    putch (' ');
+    putch (hexchar (val >> 28));
+    putch (hexchar (val >> 24));
+    putch (hexchar (val >> 20));
+    putch (hexchar (val >> 16));
+    putch (hexchar (val >> 12));
+    putch (hexchar (val >> 8));
+    putch (hexchar (val >> 4));
+    putch (hexchar (val));
+    putch ('\n');
+}
+
+int main()
+{
+    /* Initialize coprocessor 0. */
+    mtc0 (C0_COUNT, 0, 0);
+    mtc0 (C0_COMPARE, 0, -1);
+    //mtc0 (C0_EBASE, 1, 0x9fc00000);     /* Vector base */
+    //mtc0 (C0_INTCTL, 1, 1 << 5);        /* Vector spacing 32 bytes */
+    //mtc0 (C0_CAUSE, 0, 1 << 23);        /* Set IV */
+    //mtc0 (C0_STATUS, 0, 0);             /* Clear BEV */
+
+    /* Use pins PA0-PA3, PF13, PF12, PA6-PA7 as output: LED control. */
+    LATACLR = 0xCF;
+    TRISACLR = 0xCF;
+    LATFCLR = 0x3000;
+    TRISFCLR = 0x3000;
+
+    /* Initialize UART. */
+    U1RXR = 2;                          /* assign UART1 receive to pin RPF4 */
+    RPF5R = 1;                          /* assign pin RPF5 to UART1 transmit */
+
+    U1BRG = PIC32_BRG_BAUD (MHZ * 500000, 115200);
+    U1STA = 0;
+    U1MODE = PIC32_UMODE_PDSEL_8NPAR |      /* 8-bit data, no parity */
+             PIC32_UMODE_ON;                /* UART Enable */
+    U1STASET = PIC32_USTA_URXEN |           /* Receiver Enable */
+               PIC32_USTA_UTXEN;            /* Transmit Enable */
+
+    /*
+     * Print initial state of control registers.
+     */
+    putch ('-');
+    putch ('\n');
+    printreg ("Status  ", mfc0(12, 0));
+    printreg ("IntCtl  ", mfc0(12, 1));
+    printreg ("SRSCtl  ", mfc0(12, 2));
+    printreg ("Cause   ", mfc0(13, 0));
+    printreg ("PRId    ", mfc0(15, 0));
+    printreg ("EBase   ", mfc0(15, 1));
+    printreg ("CDMMBase", mfc0(15, 2));
+    printreg ("Config  ", mfc0(16, 0));
+    printreg ("Config1 ", mfc0(16, 1));
+    printreg ("Config2 ", mfc0(16, 2));
+    printreg ("Config3 ", mfc0(16, 3));
+    printreg ("Config4 ", mfc0(16, 4));
+    printreg ("Config5 ", mfc0(16, 5));
+    printreg ("Config7 ", mfc0(16, 7));
+    printreg ("WatchHi ", mfc0(19, 0));
+    printreg ("WatchHi1", mfc0(19, 1));
+    printreg ("WatchHi2", mfc0(19, 2));
+    printreg ("WatchHi3", mfc0(19, 3));
+    printreg ("Debug   ", mfc0(23, 0));
+    printreg ("PerfCtl0", mfc0(25, 0));
+    printreg ("PerfCtl1", mfc0(25, 2));
+    printreg ("DEVID   ", DEVID);
+    printreg ("OSCCON  ", OSCCON);
+    printreg ("DEVCFG0 ", DEVCFG0);
+    printreg ("DEVCFG1 ", DEVCFG1);
+    printreg ("DEVCFG2 ", DEVCFG2);
+    printreg ("DEVCFG3 ", DEVCFG3);
+
+    while (1) {
+        /* Invert pins PA7-PA0. */
+        LATAINV = 1 << 0;  udelay (100000);
+        LATAINV = 1 << 1;  udelay (100000);
+        LATAINV = 1 << 2;  udelay (100000);
+        LATAINV = 1 << 3;  udelay (100000);
+        LATFINV = 1 << 13; udelay (100000);
+        LATFINV = 1 << 12; udelay (100000);
+        LATAINV = 1 << 6;  udelay (100000);
+        LATAINV = 1 << 7;  udelay (100000);
+
+        loop++;
+        putch ('.');
+    }
+}

pool/shard010/C/0138102_capitalize.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <cs50.h>
+
+int main(void)
+{
+	string s = GetString();
+
+	for (int i = 0, n = strlen(s); i < n; i++)
+	{
+		if (s[i] >= "a" && s[i] <= "z")
+		{
+			printf("%c", s[i] - ("a" - "A"));
+		}
+		else
+		{
+			printf("%c",s[i]);
+		}
+	}
+	printf("\n");
+	return 0;
+}
+

pool/shard010/C/0138103_pthread_join.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+
+pthread_t threads[5];
+int done[5];
+
+void *thread_main(void *);
+
+int main(void)
+{
+	int i;
+	int rc;
+	// int status; pthread_join() need to get void pointer's addr
+	void *status;
+
+	for (i = 0; i < 5; i++)
+	{
+		done[i] = 0;
+		pthread_create(&threads[i], NULL, &thread_main, (void *)&i);
+		printf("thread[%d] create, %ld\n", i, threads[i]);
+	}
+
+	for (i = 4; i >= 0; i--)
+	{
+		done[i] = 1;
+		rc = pthread_join(threads[i], status);
+		printf("%p\n", status);
+		if (rc == 0)
+		{
+			printf("Completed join with thread %d status= %p\n",i, status);
+		}
+		else
+		{
+			printf("ERROR; return code from pthread_join() is %d, thread %d\n", rc, i);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+void *thread_main(void *arg)
+{
+	int i;
+	double result=0.0;
+
+	printf("thread: %d\n", *((int *)arg));
+}
+

pool/shard010/C/0138104_mca_dsm.c

@@ -0,0 +1,346 @@
+/******************************************************************************
+ *
+ *  Copyright (C) 2009-2012 Broadcom Corporation
+ *
+ *  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.
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ *  This is the implementation file for the MCAP Data chahnel state machine.
+ *
+ ******************************************************************************/
+#include <string.h>
+
+#include "bt_target.h"
+#include "mca_api.h"
+#include "mca_defs.h"
+#include "mca_int.h"
+
+/*****************************************************************************
+** data channel state machine constants and types
+*****************************************************************************/
+enum
+{
+    MCA_DCB_TC_OPEN,
+    MCA_DCB_CONG,
+    MCA_DCB_FREE_DATA,
+    MCA_DCB_DEALLOC,
+    MCA_DCB_DO_DISCONN,
+    MCA_DCB_SND_DATA,
+    MCA_DCB_HDL_DATA,
+    MCA_DCB_NUM_ACTIONS
+};
+#define MCA_DCB_IGNORE     MCA_DCB_NUM_ACTIONS
+
+/* action function list */
+const tMCA_DCB_ACTION mca_dcb_action[] = {
+    mca_dcb_tc_open,
+    mca_dcb_cong,
+    mca_dcb_free_data,
+    mca_dcb_dealloc,
+    mca_dcb_do_disconn,
+    mca_dcb_snd_data,
+    mca_dcb_hdl_data
+};
+
+/* state table information */
+#define MCA_DCB_ACTIONS            1       /* number of actions */
+#define MCA_DCB_ACT_COL            0       /* position of action function */
+#define MCA_DCB_NEXT_STATE         1       /* position of next state */
+#define MCA_DCB_NUM_COLS           2       /* number of columns in state tables */
+
+/* state table for opening state */
+const UINT8 mca_dcb_st_opening[][MCA_DCB_NUM_COLS] = {
+/* Event                            Action              Next State */
+/* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_DO_DISCONN,   MCA_DCB_CLOSING_ST},
+/* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_OPENING_ST},
+/* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_TC_OPEN,      MCA_DCB_OPEN_ST},
+/* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
+/* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_CONG,         MCA_DCB_OPENING_ST},
+/* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_FREE_DATA,    MCA_DCB_OPENING_ST}
+};
+
+/* state table for open state */
+const UINT8 mca_dcb_st_open[][MCA_DCB_NUM_COLS] = {
+/* Event                            Action              Next State */
+/* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_DO_DISCONN,   MCA_DCB_CLOSING_ST},
+/* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_SND_DATA,     MCA_DCB_OPEN_ST},
+/* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_IGNORE,       MCA_DCB_OPEN_ST},
+/* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
+/* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_CONG,         MCA_DCB_OPEN_ST},
+/* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_HDL_DATA,     MCA_DCB_OPEN_ST}
+};
+
+/* state table for closing state */
+const UINT8 mca_dcb_st_closing[][MCA_DCB_NUM_COLS] = {
+/* Event                            Action              Next State */
+/* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
+/* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
+/* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_TC_OPEN,      MCA_DCB_OPEN_ST},
+/* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
+/* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
+/* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_FREE_DATA,    MCA_DCB_CLOSING_ST}
+};
+
+/* type for state table */
+typedef const UINT8 (*tMCA_DCB_ST_TBL)[MCA_DCB_NUM_COLS];
+
+/* state table */
+const tMCA_DCB_ST_TBL mca_dcb_st_tbl[] = {
+    mca_dcb_st_opening,
+    mca_dcb_st_open,
+    mca_dcb_st_closing
+};
+
+#if (BT_TRACE_VERBOSE == TRUE)
+/* verbose event strings for trace */
+const char * const mca_dcb_evt_str[] = {
+    "API_CLOSE_EVT",
+    "API_WRITE_EVT",
+    "TC_OPEN_EVT",
+    "TC_CLOSE_EVT",
+    "TC_CONG_EVT",
+    "TC_DATA_EVT"
+};
+/* verbose state strings for trace */
+const char * const mca_dcb_st_str[] = {
+    "NULL_ST",
+    "OPENING_ST",
+    "OPEN_ST",
+    "CLOSING_ST"
+};
+#endif
+
+/*******************************************************************************
+**
+** Function         mca_dcb_event
+**
+** Description      This function is the DCB state machine main function.
+**                  It uses the state and action function tables to execute
+**                  action functions.
+**
+** Returns          void.
+**
+*******************************************************************************/
+void mca_dcb_event(tMCA_DCB *p_dcb, UINT8 event, tMCA_DCB_EVT *p_data)
+{
+    tMCA_DCB_ST_TBL    state_table;
+    UINT8              action;
+
+    if (p_dcb == NULL)
+        return;
+#if (BT_TRACE_VERBOSE == TRUE)
+    MCA_TRACE_EVENT("DCB dcb=%d event=%s state=%s", mca_dcb_to_hdl(p_dcb), mca_dcb_evt_str[event], mca_dcb_st_str[p_dcb->state]);
+#else
+    MCA_TRACE_EVENT("DCB dcb=%d event=%d state=%d", mca_dcb_to_hdl(p_dcb), event, p_dcb->state);
+#endif
+
+    /* look up the state table for the current state */
+    state_table = mca_dcb_st_tbl[p_dcb->state - 1];
+
+    /* set next state */
+    p_dcb->state = state_table[event][MCA_DCB_NEXT_STATE];
+
+    /* execute action functions */
+    if ((action = state_table[event][MCA_DCB_ACT_COL]) != MCA_DCB_IGNORE)
+    {
+        (*mca_dcb_action[action])(p_dcb, p_data);
+    }
+}
+
+/*******************************************************************************
+**
+** Function         mca_dcb_alloc
+**
+** Description      This function is called to allocate an DCB.
+**                  It initializes the DCB with the data passed to the function.
+**
+** Returns          tMCA_DCB *
+**
+*******************************************************************************/
+tMCA_DCB *mca_dcb_alloc(tMCA_CCB*p_ccb, tMCA_DEP dep)
+{
+    tMCA_DCB *p_dcb = NULL, *p_dcb_tmp;
+    tMCA_RCB *p_rcb = p_ccb->p_rcb;
+    tMCA_CS  *p_cs;
+    int       i, max;
+
+    if (dep < MCA_NUM_DEPS)
+    {
+        p_cs = &p_rcb->dep[dep];
+        i = mca_ccb_to_hdl(p_ccb)-1;
+        p_dcb_tmp = &mca_cb.dcb[i*MCA_NUM_MDLS];
+        /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
+        max = p_cs->max_mdl;
+        for (i=0; i<max; i++, p_dcb_tmp++)
+        {
+            if (p_dcb_tmp->state == MCA_DCB_NULL_ST)
+            {
+                p_dcb_tmp->p_ccb = p_ccb;
+                p_dcb_tmp->state = MCA_DCB_OPENING_ST;
+                p_dcb_tmp->cong  = TRUE;
+                p_dcb_tmp->p_cs  = p_cs;
+                p_dcb = p_dcb_tmp;
+                break;
+            }
+        }
+    }
+    return p_dcb;
+}
+
+/*******************************************************************************
+**
+** Function         mca_dep_free_mdl
+**
+** Description      This function is called to check the number of free mdl for
+**                  the given dep.
+**
+** Returns          the number of free mdl for the given dep
+**
+*******************************************************************************/
+UINT8 mca_dep_free_mdl(tMCA_CCB *p_ccb, tMCA_DEP dep)
+{
+    tMCA_DCB *p_dcb;
+    tMCA_RCB *p_rcb = p_ccb->p_rcb;
+    tMCA_CS  *p_cs;
+    int       i, max;
+    UINT8   count = 0;
+    UINT8   left;
+
+    if (dep < MCA_NUM_DEPS)
+    {
+        p_cs = &p_rcb->dep[dep];
+        i = mca_ccb_to_hdl(p_ccb)-1;
+        p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
+        /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
+        max = p_cs->max_mdl;
+        for (i=0; i<max; i++, p_dcb++)
+        {
+            if ((p_dcb->state != MCA_DCB_NULL_ST) && (p_dcb->p_cs == p_cs))
+            {
+                count++;
+                break;
+            }
+        }
+    }
+    else
+    {
+        max = 0;
+        MCA_TRACE_WARNING("Invalid Dep ID");
+    }
+    left = max - count;
+    return left;
+}
+
+/*******************************************************************************
+**
+** Function         mca_dcb_dealloc
+**
+** Description      This function deallocates an DCB.
+**
+** Returns          void.
+**
+*******************************************************************************/
+void mca_dcb_dealloc(tMCA_DCB *p_dcb, tMCA_DCB_EVT *p_data)
+{
+    tMCA_CCB *p_ccb = p_dcb->p_ccb;
+    UINT8    event = MCA_CLOSE_IND_EVT;
+    tMCA_CTRL   evt_data;
+
+    MCA_TRACE_DEBUG("mca_dcb_dealloc");
+    mca_free_buf ((void **)&p_dcb->p_data);
+    if (p_data)
+    {
+        /* non-NULL -> an action function -> report disconnect event */
+        evt_data.close_cfm.mdl      = mca_dcb_to_hdl(p_dcb);
+        evt_data.close_cfm.reason   = p_data->close.reason;
+        evt_data.close_cfm.mdl_id   = p_dcb->mdl_id;
+        if (p_data->close.param == MCA_INT)
+            event = MCA_CLOSE_CFM_EVT;
+        if (p_data->close.lcid)
+            mca_ccb_report_event(p_ccb, event, &evt_data);
+    }
+    mca_free_tc_tbl_by_lcid (p_dcb->lcid);
+    memset (p_dcb, 0, sizeof (tMCA_DCB));
+}
+
+/*******************************************************************************
+**
+** Function         mca_dcb_to_hdl
+**
+** Description      This function converts a pointer to an DCB to a handle (tMCA_DL).
+**                  It returns the handle.
+**
+** Returns          tMCA_DL.
+**
+*******************************************************************************/
+tMCA_DL mca_dcb_to_hdl(tMCA_DCB *p_dcb)
+{
+    return (UINT8) (p_dcb - mca_cb.dcb + 1);
+}
+
+/*******************************************************************************
+**
+** Function         mca_dcb_by_hdl
+**
+** Description      This function finds the DCB for a handle (tMCA_DL).
+**                  It returns a pointer to the DCB.
+**                  If no DCB matches the handle it returns NULL.
+**
+** Returns          tMCA_DCB *
+**
+*******************************************************************************/
+tMCA_DCB *mca_dcb_by_hdl(tMCA_DL hdl)
+{
+    tMCA_DCB * p_dcb = NULL;
+    if (hdl && hdl <= MCA_NUM_DCBS && mca_cb.dcb[hdl-1].state)
+        p_dcb = &mca_cb.dcb[hdl-1];
+    return p_dcb;
+}
+
+/*******************************************************************************
+**
+** Function         mca_dcb_close_by_mdl_id
+**
+** Description      This function finds the DCB for a mdl_id and
+**                  disconnect the mdl
+**
+** Returns          void
+**
+*******************************************************************************/
+void mca_dcb_close_by_mdl_id(tMCA_CCB*p_ccb, UINT16 mdl_id)
+{
+    tMCA_DCB *p_dcb;
+    int       i;
+
+    MCA_TRACE_DEBUG("mca_dcb_close_by_mdl_id mdl_id=%d", mdl_id);
+    i = mca_ccb_to_hdl(p_ccb)-1;
+    p_dcb = &mca_cb.dcb[i*MCA_NUM_MDLS];
+    for (i=0; i<MCA_NUM_MDLS; i++, p_dcb++)
+    {
+        if (p_dcb->state)
+        {
+            if (p_dcb->mdl_id == mdl_id)
+            {
+                mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
+                break;
+            }
+            else if (mdl_id == MCA_ALL_MDL_ID)
+            {
+                mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
+            }
+        }
+    }
+}

pool/shard010/C/0138105_thread_tcache_enabled.c

@@ -0,0 +1,89 @@
+#include "test/jemalloc_test.h"
+
+void *
+thd_start(void *arg) {
+	bool e0, e1;
+	size_t sz = sizeof(bool);
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz, NULL,
+	    0), 0, "Unexpected mallctl failure");
+
+	if (e0) {
+		e1 = false;
+		assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+		    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+		assert_true(e0, "tcache should be enabled");
+	}
+
+	e1 = true;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_false(e0, "tcache should be disabled");
+
+	e1 = true;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_true(e0, "tcache should be enabled");
+
+	e1 = false;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_true(e0, "tcache should be enabled");
+
+	e1 = false;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_false(e0, "tcache should be disabled");
+
+	free(malloc(1));
+	e1 = true;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_false(e0, "tcache should be disabled");
+
+	free(malloc(1));
+	e1 = true;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_true(e0, "tcache should be enabled");
+
+	free(malloc(1));
+	e1 = false;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_true(e0, "tcache should be enabled");
+
+	free(malloc(1));
+	e1 = false;
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz,
+	    (void *)&e1, sz), 0, "Unexpected mallctl() error");
+	assert_false(e0, "tcache should be disabled");
+
+	free(malloc(1));
+	return NULL;
+	test_skip("\"thread.tcache.enabled\" mallctl not available");
+	return NULL;
+}
+
+TEST_BEGIN(test_main_thread) {
+	thd_start(NULL);
+}
+TEST_END
+
+TEST_BEGIN(test_subthread) {
+	thd_t thd;
+
+	thd_create(&thd, thd_start, NULL);
+	thd_join(thd, NULL);
+}
+TEST_END
+
+int
+main(void) {
+	/* Run tests multiple times to check for bad interactions. */
+	return test(
+	    test_main_thread,
+	    test_subthread,
+	    test_main_thread,
+	    test_subthread,
+	    test_main_thread);
+}

pool/shard010/C/0138106_watchman.c

@@ -0,0 +1,82 @@
+#include "bbs.h"
+
+#define DEFAULT_ADD 600
+#define CONT MY_BBS_HOME "/help/watchmanhelp"
+
+struct bbsinfo bbsinfo;
+
+void
+usage(char *name)
+{
+	printf("%s userid userpasswd [minutes_to_delay]\n", name);
+}
+
+int
+main(int argc, char *argv[])
+{
+	struct UTMPFILE *shm_utmp;
+	int time_add = 0;
+	int i;
+	FILE *fp, *fr;
+	time_t now_t;
+	char buf[256];
+	if (argc < 3) {
+		usage(argv[0]);
+		return 0;
+	}
+	//errlog("argc:%d",argc);
+	if (argc > 3){
+		time_add = atoi(argv[3]) * 60;
+	//	errlog("argv[3]: %s",argv[3]);
+	}
+	if (!time_add)
+		time_add = DEFAULT_ADD;
+	for (i = 0; i < 10; i++) {
+		initbbsinfo(&bbsinfo);
+		shm_utmp = bbsinfo.utmpshm;
+		if (shm_utmp)
+			break;
+		sleep(10);
+	}
+	if (!shm_utmp) {
+		errlog("can't attach ushm!");
+		return -1;
+	}
+	now_t = time(NULL);
+	if (shm_utmp->watchman) {
+		strcpy(buf,
+		       "¡ï¡ï¡ï¡ï¡ï¾¯±¨¡ï¡ï¡ï¡ï¡ïÕþÖÎÐÔ°æÃæËøסÁË¡ï¡ï¡ï¡ï¡ï");
+	} else {
+		shm_utmp->watchman = now_t + time_add;
+		getrandomint(&(shm_utmp->unlock));
+		snprintf(buf, sizeof (buf), "À´À´À´,µãîÁË!ÏÖÔÚÊÇ %s",
+			 Ctime(now_t));
+	}
+
+	fp = popen("/usr/bin/mail bbs", "w");
+	if (!fp) {
+		errlog("can't open mail!");
+		return -2;
+	}
+	fr = fopen(CONT, "r");
+	fprintf(fp, "#name: %s\n", argv[1]);
+	fprintf(fp, "#pass: %s\n", argv[2]);
+	fprintf(fp, "#board: deleterequest\n");
+	fprintf(fp, "#title: %s\n", buf);
+	fprintf(fp, "#localpost:\n\n");
+	if (!strncmp(buf, "À´", 2)) {
+		fprintf(fp,
+			"ÇëÔÚ%d·ÖÖÓÄÚ½øÐнâËø²Ù×÷,·ñÔò±¾BBSËùÓкÍÕþÖÎÏà¹ØµÄ°æÃ潫±»·â°æ\n"
+			"Ö±ÖÁÓÐÈ˽øÐÐÁ˽âËø²Ù×÷.\n" "½âËøÃÜÂë: %u\n",
+			time_add / 60, shm_utmp->unlock % 10000);
+	}
+	fprintf(fp, "ÒÔÏÂÊǹØÓÚ½âËø²Ù×÷µÄ˵Ã÷:\n");
+	fr = fopen(CONT, "r");
+	if (fr) {
+		while (fgets(buf, sizeof (buf), fr))
+			fputs(buf, fp);
+		fclose(fr);
+	}
+	pclose(fp);
+	return 0;
+}

pool/shard010/C/0138107_p_verify.c

@@ -0,0 +1,119 @@
+/* crypto/evp/p_verify.c */
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ * 
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ * 
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from 
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * 
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+
+#include <stdio.h>
+#include "cryptlib.h"
+#include <openssl/evp.h>
+#include <openssl/objects.h>
+#include <openssl/x509.h>
+
+int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
+	     unsigned int siglen, EVP_PKEY *pkey)
+	{
+	unsigned char m[EVP_MAX_MD_SIZE];
+	unsigned int m_len;
+	int i,ok=0,v;
+	MS_STATIC EVP_MD_CTX tmp_ctx;
+
+	EVP_MD_CTX_init(&tmp_ctx);
+	EVP_MD_CTX_copy_ex(&tmp_ctx,ctx);     
+	EVP_DigestFinal_ex(&tmp_ctx,&(m[0]),&m_len);
+	EVP_MD_CTX_cleanup(&tmp_ctx);
+
+	if (ctx->digest->flags & EVP_MD_FLAG_PKEY_METHOD_SIGNATURE)
+		{
+		EVP_PKEY_CTX *pkctx = NULL;
+		i = -1;
+		pkctx = EVP_PKEY_CTX_new(pkey, NULL);
+		if (!pkctx)
+			goto err;
+		if (EVP_PKEY_verify_init(pkctx) <= 0)
+			goto err;
+		if (EVP_PKEY_CTX_set_signature_md(pkctx, ctx->digest) <= 0)
+			goto err;
+		i = EVP_PKEY_verify(pkctx, sigbuf, siglen, m, m_len);
+		err:
+		EVP_PKEY_CTX_free(pkctx);
+		return i;
+		}
+
+	for (i=0; i<4; i++)
+		{
+		v=ctx->digest->required_pkey_type[i];
+		if (v == 0) break;
+		if (pkey->type == v)
+			{
+			ok=1;
+			break;
+			}
+		}
+	if (!ok)
+		{
+		EVPerr(EVP_F_EVP_VERIFYFINAL,EVP_R_WRONG_PUBLIC_KEY_TYPE);
+		return(-1);
+		}
+        if (ctx->digest->verify == NULL)
+                {
+		EVPerr(EVP_F_EVP_VERIFYFINAL,EVP_R_NO_VERIFY_FUNCTION_CONFIGURED);
+		return(0);
+		}
+
+	return(ctx->digest->verify(ctx->digest->type,m,m_len,
+		sigbuf,siglen,pkey->pkey.ptr));
+	}
+

pool/shard010/C/0138108_i915_random.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright © 2016 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ */
+
+#include <linux/bitops.h>
+#include <linux/kernel.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#include "i915_random.h"
+#include "i915_utils.h"
+
+u64 i915_prandom_u64_state(struct rnd_state *rnd)
+{
+	u64 x;
+
+	x = prandom_u32_state(rnd);
+	x <<= 32;
+	x |= prandom_u32_state(rnd);
+
+	return x;
+}
+
+void i915_prandom_shuffle(void *arr, size_t elsz, size_t count,
+			  struct rnd_state *state)
+{
+	char stack[128];
+
+	if (WARN_ON(elsz > sizeof(stack) || count > U32_MAX))
+		return;
+
+	if (!elsz || !count)
+		return;
+
+	/* Fisher-Yates shuffle courtesy of Knuth */
+	while (--count) {
+		size_t swp;
+
+		swp = i915_prandom_u32_max_state(count + 1, state);
+		if (swp == count)
+			continue;
+
+		memcpy(stack, arr + count * elsz, elsz);
+		memcpy(arr + count * elsz, arr + swp * elsz, elsz);
+		memcpy(arr + swp * elsz, stack, elsz);
+	}
+}
+
+void i915_random_reorder(unsigned int *order, unsigned int count,
+			 struct rnd_state *state)
+{
+	i915_prandom_shuffle(order, sizeof(*order), count, state);
+}
+
+unsigned int *i915_random_order(unsigned int count, struct rnd_state *state)
+{
+	unsigned int *order, i;
+
+	order = kmalloc_array(count, sizeof(*order),
+			      GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN);
+	if (!order)
+		return order;
+
+	for (i = 0; i < count; i++)
+		order[i] = i;
+
+	i915_random_reorder(order, count, state);
+	return order;
+}
+
+u64 igt_random_offset(struct rnd_state *state,
+		      u64 start, u64 end,
+		      u64 len, u64 align)
+{
+	u64 range, addr;
+
+	BUG_ON(range_overflows(start, len, end));
+	BUG_ON(round_up(start, align) > round_down(end - len, align));
+
+	range = round_down(end - len, align) - round_up(start, align);
+	if (range) {
+		addr = i915_prandom_u64_state(state);
+		div64_u64_rem(addr, range, &addr);
+		start += addr;
+	}
+
+	return round_up(start, align);
+}

pool/shard010/C/0138109_networkd-netdev-vlan.c

@@ -0,0 +1,81 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2013 Tom Gundersen <teg@jklm.no>
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <net/if.h>
+
+#include "networkd-netdev-vlan.h"
+#include "network-internal.h"
+#include "list.h"
+
+static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_rtnl_message *req) {
+        VLan *v = VLAN(netdev);
+        int r;
+
+        assert(netdev);
+        assert(v);
+        assert(link);
+        assert(req);
+
+        if (v->id <= VLANID_MAX) {
+                r = sd_rtnl_message_append_u16(req, IFLA_VLAN_ID, v->id);
+                if (r < 0) {
+                        log_error_netdev(netdev,
+                                         "Could not append IFLA_VLAN_ID attribute: %s",
+                                         strerror(-r));
+                        return r;
+                }
+        }
+
+        return 0;
+}
+
+static int netdev_vlan_verify(NetDev *netdev, const char *filename) {
+        VLan *v = VLAN(netdev);
+
+        assert(netdev);
+        assert(v);
+        assert(filename);
+
+        if (v->id > VLANID_MAX) {
+                log_warning("VLAN without valid Id (%"PRIu64") configured in %s. Ignoring", v->id, filename);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void vlan_init(NetDev *netdev) {
+        VLan *v = VLAN(netdev);
+
+        assert(netdev);
+        assert(v);
+
+        v->id = VLANID_MAX + 1;
+}
+
+const NetDevVTable vlan_vtable = {
+        .object_size = sizeof(VLan),
+        .init = vlan_init,
+        .sections = "Match\0NetDev\0VLAN\0",
+        .fill_message_create = netdev_vlan_fill_message_create,
+        .create_type = NETDEV_CREATE_STACKED,
+        .config_verify = netdev_vlan_verify,
+};

pool/shard010/C/0138110_main.c

@@ -0,0 +1,298 @@
+/**
+  ******************************************************************************
+  * @file    ADC/ADC_TriggerMode/Src/main.c
+  * @author  MCD Application Team
+  * @brief   This example describes how to use Timer to trig ADC conversion.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+  *
+  * Redistribution and use in source and binary forms, with or without modification,
+  * are permitted provided that the following conditions are met:
+  *   1. Redistributions of source code must retain the above copyright notice,
+  *      this list of conditions and the following disclaimer.
+  *   2. Redistributions in binary form must reproduce the above copyright notice,
+  *      this list of conditions and the following disclaimer in the documentation
+  *      and/or other materials provided with the distribution.
+  *   3. Neither the name of STMicroelectronics nor the names of its contributors
+  *      may be used to endorse or promote products derived from this software
+  *      without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "main.h"
+
+/** @addtogroup STM32F0xx_HAL_Examples
+  * @{
+  */
+
+/** @addtogroup ADC_TriggerMode
+  * @{
+  */
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* ADC handler declaration */
+ADC_HandleTypeDef    AdcHandle;
+
+/* TIM handler declaration */
+static TIM_HandleTypeDef  htim;
+
+/* Variable used to get converted value */
+__IO uint16_t uhADCxConvertedValue = 0;
+
+/* Private function prototypes -----------------------------------------------*/
+static void SystemClock_Config(void);
+static void Error_Handler(void);
+static void ADC_Config(void);
+static void TIM_Config(void);
+
+/* Private functions ---------------------------------------------------------*/
+
+/**
+  * @brief  Main program.
+  * @param  None
+  * @retval None
+  */
+int main(void)
+{
+  /* STM32F0xx HAL library initialization:
+       - Configure the Flash prefetch
+       - Systick timer is configured by default as source of time base, but user 
+         can eventually implement his proper time base source (a general purpose 
+         timer for example or other time source), keeping in mind that Time base 
+         duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and 
+         handled in milliseconds basis.
+       - Low Level Initialization
+     */
+  HAL_Init();
+
+  /* Configure LED3 */
+  BSP_LED_Init(LED3);
+
+  /* Configure the system clock to 48 MHz */
+  SystemClock_Config();
+
+  /*##-1- TIM Peripheral Configuration ######################################*/
+  TIM_Config();
+
+  /*##-2- Configure the ADC peripheral ######################################*/
+  ADC_Config();
+
+  /*##-4- Start the conversion process and enable interrupt ##################*/
+  if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
+  {
+    /* Start Conversation Error */
+    Error_Handler();
+  }
+
+  /*##-3- TIM counter enable ################################################*/
+  if (HAL_TIM_Base_Start(&htim) != HAL_OK)
+  {
+    /* Counter Enable Error */
+    Error_Handler();
+  }
+
+  /* Infinite loop */
+  while (1)
+  {
+  }
+}
+
+/**
+  * @brief  System Clock Configuration
+  *         The system Clock is configured as follow : 
+  *            System Clock source            = PLL (HSE)
+  *            SYSCLK(Hz)                     = 48000000
+  *            HCLK(Hz)                       = 48000000
+  *            AHB Prescaler                  = 1
+  *            APB1 Prescaler                 = 1
+  *            HSE Frequency(Hz)              = 8000000
+  *            PREDIV                         = 1
+  *            PLLMUL                         = 6
+  *            Flash Latency(WS)              = 1
+  * @param  None
+  * @retval None
+  */
+static void SystemClock_Config(void)
+{
+  RCC_ClkInitTypeDef RCC_ClkInitStruct;
+  RCC_OscInitTypeDef RCC_OscInitStruct;
+  
+  /* Enable HSE Oscillator and Activate PLL with HSE as source */
+  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
+  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
+  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
+  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
+  RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
+  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
+  if (HAL_RCC_OscConfig(&RCC_OscInitStruct)!= HAL_OK)
+  {
+    Error_Handler(); 
+  }
+
+  /* Select PLL as system clock source and configure the HCLK, PCLK1 clocks dividers */
+  RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1);
+  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
+  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
+  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
+  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1)!= HAL_OK)
+  {
+    Error_Handler(); 
+  }
+}
+
+/**
+  * @brief  This function is executed in case of error occurrence.
+  * @param  None
+  * @retval None
+  */
+static void Error_Handler(void)
+{
+  /* Turn LED3 on */
+  BSP_LED_On(LED3);
+  while (1)
+  {
+  }
+}
+
+/**
+  * @brief  ADC configuration
+  * @param  None
+  * @retval None
+  */
+static void ADC_Config(void)
+{
+  ADC_ChannelConfTypeDef sConfig;
+
+  /* ADC Initialization */
+  AdcHandle.Instance          = ADCx;
+  
+  AdcHandle.Init.ClockPrescaler        = ADC_CLOCK_SYNC_PCLK_DIV4;
+  AdcHandle.Init.Resolution            = ADC_RESOLUTION_12B;
+  AdcHandle.Init.DataAlign             = ADC_DATAALIGN_RIGHT;
+  AdcHandle.Init.ScanConvMode          = DISABLE;                       /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
+  AdcHandle.Init.EOCSelection          = ADC_EOC_SINGLE_CONV;
+  AdcHandle.Init.LowPowerAutoWait      = DISABLE;
+  AdcHandle.Init.LowPowerAutoPowerOff  = DISABLE;
+  AdcHandle.Init.ContinuousConvMode    = DISABLE;                       /* Continuous mode disabled to have only 1 conversion at each conversion trig */
+  AdcHandle.Init.DiscontinuousConvMode = DISABLE;                       /* Parameter discarded because sequencer is disabled */
+  AdcHandle.Init.ExternalTrigConv      = ADC_EXTERNALTRIGCONV_T2_TRGO;       /* Conversion start trigged at each external event */
+  AdcHandle.Init.ExternalTrigConvEdge  = ADC_EXTERNALTRIGCONVEDGE_RISING;
+  AdcHandle.Init.DMAContinuousRequests = ENABLE;
+  AdcHandle.Init.Overrun               = ADC_OVR_DATA_OVERWRITTEN;
+
+  if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
+  {
+    /* ADC initiliazation Error */
+    Error_Handler();
+  }
+
+  /* Configure ADC regular channel */
+  sConfig.Channel      = ADCx_CHANNEL;
+  sConfig.Rank         = ADC_RANK_CHANNEL_NUMBER;
+  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES_5;
+
+  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
+  {
+    /* Channel Configuration Error */
+    Error_Handler();
+  }
+}
+
+/**
+  * @brief  TIM configuration
+  * @param  None
+  * @retval None
+  */
+static void TIM_Config(void)
+{
+  TIM_MasterConfigTypeDef sMasterConfig;
+
+  /* Time Base configuration */
+  htim.Instance = TIMx;
+
+  htim.Init.Period            = 2400;
+  htim.Init.Prescaler         = 0;
+  htim.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;
+  htim.Init.CounterMode       = TIM_COUNTERMODE_UP;
+  htim.Init.RepetitionCounter = 0x0;
+  htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+
+  if (HAL_TIM_Base_Init(&htim) != HAL_OK)
+  {
+    /* Timer Initiliazation Error */
+    Error_Handler();
+  }
+
+  /* Timer TRGO selection */
+  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
+  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+
+  if (HAL_TIMEx_MasterConfigSynchronization(&htim, &sMasterConfig) != HAL_OK)
+  {
+    /* Timer TRGO selection Error */
+    Error_Handler();
+  }
+}
+
+/**
+  * @brief  Conversion complete callback in non blocking mode
+  * @param  AdcHandle : AdcHandle handle
+  * @note   This example shows a simple way to report end of conversion, and
+  *         you can add your own implementation.
+  * @retval None
+  */
+void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *AdcHandle)
+{
+  /* Get the converted value of regular channel */
+  uhADCxConvertedValue = HAL_ADC_GetValue(AdcHandle);
+}
+
+#ifdef  USE_FULL_ASSERT
+
+/**
+  * @brief  Reports the name of the source file and the source line number
+  *         where the assert_param error has occurred.
+  * @param  file: pointer to the source file name
+  * @param  line: assert_param error line source number
+  * @retval None
+  */
+void assert_failed(uint8_t *file, uint32_t line)
+{
+  /* User can add his own implementation to report the file name and line number,
+     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
+
+  /* Infinite loop */
+  while (1)
+  {
+  }
+}
+
+#endif
+
+/**
+  * @}
+  */
+
+/**
+  * @}
+  */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

pool/shard010/C/0138111_strlcpy.c

@@ -0,0 +1,64 @@
+/* $Id: strlcpy.c,v 1.1 2002/04/11 16:39:59 provos Exp $ */
+/*	$OpenBSD: strlcpy.c,v 1.2 1998/11/06 04:33:16 wvdputte Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: strlcpy.c,v 1.2 1998/11/06 04:33:16 wvdputte Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t strlcpy(dst, src, siz)
+	char *dst;
+	const char *src;
+	size_t siz;
+{
+	register char *d = dst;
+	register const char *s = src;
+	register size_t n = siz;
+
+	if (n == 0)
+		return(strlen(s));
+	while (*s != '\0') {
+		if (n != 1) {
+			*d++ = *s;
+			n--;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return(s - src);	/* count does not include NUL */
+}

pool/shard010/C/0138112_kxsd9-spi.c

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/spi/spi.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/regmap.h>
+
+#include "kxsd9.h"
+
+static int kxsd9_spi_probe(struct spi_device *spi)
+{
+	static const struct regmap_config config = {
+		.reg_bits = 8,
+		.val_bits = 8,
+		.max_register = 0x0e,
+	};
+	struct regmap *regmap;
+
+	spi->mode = SPI_MODE_0;
+	regmap = devm_regmap_init_spi(spi, &config);
+	if (IS_ERR(regmap)) {
+		dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
+			__func__, PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
+
+	return kxsd9_common_probe(&spi->dev,
+				  regmap,
+				  spi_get_device_id(spi)->name);
+}
+
+static int kxsd9_spi_remove(struct spi_device *spi)
+{
+	kxsd9_common_remove(&spi->dev);
+
+	return 0;
+}
+
+static const struct spi_device_id kxsd9_spi_id[] = {
+	{"kxsd9", 0},
+	{ },
+};
+MODULE_DEVICE_TABLE(spi, kxsd9_spi_id);
+
+static const struct of_device_id kxsd9_of_match[] = {
+        { .compatible = "kionix,kxsd9" },
+        { },
+};
+MODULE_DEVICE_TABLE(of, kxsd9_of_match);
+
+static struct spi_driver kxsd9_spi_driver = {
+	.driver = {
+		.name = "kxsd9",
+		.pm = &kxsd9_dev_pm_ops,
+		.of_match_table = kxsd9_of_match,
+	},
+	.probe = kxsd9_spi_probe,
+	.remove = kxsd9_spi_remove,
+	.id_table = kxsd9_spi_id,
+};
+module_spi_driver(kxsd9_spi_driver);
+
+MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
+MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
+MODULE_LICENSE("GPL v2");