text:
package org.softlang.server;

import org.softlang.server.company.*;

public class SampleCompany {

	public static Company getSampleCompany() {
		Company company = new Company();

		company.setName("meganalysis");

		Person craig = new Person();
		craig.setName("Craig");
		craig.setAddress("Redmond");
		Person erik = new Person();
		erik.setName("Erik");
		erik.setAddress("Utrecht");
		Person ralf = new Person();
		ralf.setName("Ralf");
		ralf.setAddress("Koblenz");
		Person ray = new Person();
		ray.setName("Ray");
		ray.setAddress("Redmond");
		Person klaus = new Person();
		klaus.setName("Klaus");
		klaus.setAddress("Boston");
		Person karl = new Person();
		karl.setName("Karl");
		karl.setAddress("Riga");
		Person joe = new Person();
		joe.setName("Joe");
		joe.setAddress("Wifi City");

		Employee CraigE = new Employee();
		Employee erikE = new Employee();
		Employee ralfE = new Employee();
		Employee rayE = new Employee();
		Employee klausE = new Employee();
		Employee karlE = new Employee();
		Employee joeE = new Employee();

		CraigE.setPerson(craig);
		erikE.setPerson(erik);
		ralfE.setPerson(ralf);
		rayE.setPerson(ray);
		klausE.setPerson(klaus);
		karlE.setPerson(karl);
		joeE.setPerson(joe);

		CraigE.setSalary(123456);
		erikE.setSalary(12345);
		ralfE.setSalary(1234);
		rayE.setSalary(234567);
		klausE.setSalary(23456);
		karlE.setSalary(2345);
		joeE.setSalary(2344);

		Dept research = new Dept();
		Subunit researchS1 = new Subunit();
		Subunit researchS2 = new Subunit();

		research.setManager(CraigE);
		research.setName("Research");
		researchS1.setPu(erikE);
		researchS2.setPu(ralfE);
		research.getSubunits().add(researchS1);
		research.getSubunits().add(researchS2);

		Dept development = new Dept();
		development.setManager(rayE);
		development.setName("Development");
		Subunit developmentS1 = new Subunit();
		development.getSubunits().add(developmentS1);
		Dept dev1 = new Dept();
		dev1.setName("Dev1");
		dev1.setManager(klausE);
		developmentS1.setDu(dev1);
		Subunit dev1S1 = new Subunit();
		dev1.getSubunits().add(dev1S1);
		Dept dev11 = new Dept();
		dev11.setName("Dev1.1");
		dev11.setManager(karlE);
		dev1S1.setDu(dev11);
		Subunit dev11S1 = new Subunit();
		dev11S1.setPu(joeE);
		dev11.getSubunits().add(dev11S1);

		company.getDepts().add(research);
		company.getDepts().add(development);

		return company;

	}

}


text:
import * as toolLib from 'vsts-task-tool-lib/tool';
import * as taskLib from 'vsts-task-lib/task';
import * as restm from 'typed-rest-client/RestClient';
import * as path from 'path';
import * as commandHelper from './CommandHelper';
interface INuGetTools {
    nugetexe: INuGetVersionInfo[]
}

interface INuGetVersionInfo {
    version: string,
    url: string,
    stage: NuGetReleaseStage
}

enum NuGetReleaseStage
{
    "EarlyAccessPreview",
    "Released",
    "ReleasedAndBlessed"
}

const NUGET_TOOL_NAME: string = 'NuGet';
const NUGET_EXE_FILENAME: string = 'nuget.exe';
const NUGET_VERSION_4_0_0: string = '4.0.0';

export const NUGET_EXE_TOOL_PATH_ENV_VAR: string = 'NuGetExeToolPath';

export async function getNuGet(versionSpec: string, checkLatest?: boolean, addNuGetToPath?: boolean): Promise<string> {
    if (toolLib.isExplicitVersion(versionSpec)) {
        // Check latest doesn't make sense when explicit version
        checkLatest = false;
        taskLib.debug('Exact match expected on version: ' + versionSpec);
    }
    else {
        taskLib.debug('Query match expected on version: ' + versionSpec);
        console.log(taskLib.loc("Info_ExpectBehaviorChangeWhenUsingVersionQuery"));
    }

    // If we're not checking latest, check the cache first
    let toolPath: string;
    if (!checkLatest) {
        taskLib.debug('Trying to get tool from local cache');
        toolPath = toolLib.findLocalTool(NUGET_TOOL_NAME, versionSpec);
    }

    let localVersions: string[] = toolLib.findLocalToolVersions(NUGET_TOOL_NAME);
    let version: string = toolLib.evaluateVersions(localVersions, versionSpec);

    if (toolPath) {
        // If here, then we're not checking latest and we found the tool in cache
        console.log(taskLib.loc("Info_ResolvedToolFromCache", version));
    }
    else {
        let versionInfo: INuGetVersionInfo = await getLatestMatchVersionInfo(versionSpec);

        // There is a local version which matches the spec yet we found one on dist.nuget.org
        // which is different, so we're about to change the version which was used
        if (version && version !== versionInfo.version) {
            taskLib.warning(taskLib.loc("Warning_UpdatingNuGetVersion", versionInfo.version, version));
        }

        version = versionInfo.version;
        taskLib.debug('Found the following version from the list: ' + version);

        if (!versionInfo.url)
        {
            taskLib.error(taskLib.loc("Error_NoUrlWasFoundWhichMatches", version));
            throw new Error(taskLib.loc("Error_NuGetToolInstallerFailer", NUGET_TOOL_NAME));
        }

        toolPath = toolLib.findLocalTool(NUGET_TOOL_NAME, version);

        if (!toolPath) {
            taskLib.debug('Downloading version: ' + version);
            let downloadPath: string = await toolLib.downloadTool(versionInfo.url);

            taskLib.debug('Caching file');
            toolLib.cacheFile(downloadPath, NUGET_EXE_FILENAME, NUGET_TOOL_NAME, version);
        }
    }

    console.log(taskLib.loc("Info_UsingVersion", version));
    toolPath= toolLib.findLocalTool(NUGET_TOOL_NAME, version);

    if (addNuGetToPath){
        console.log(taskLib.loc("Info_UsingToolPath", toolPath));
        toolLib.prependPath(toolPath);
    }

    let fullNuGetPath: string = path.join(toolPath, NUGET_EXE_FILENAME);
    taskLib.setVariable(NUGET_EXE_TOOL_PATH_ENV_VAR, fullNuGetPath);

    return fullNuGetPath;
}

export async function cacheBundledNuGet_4_0_0() {
    if (!toolLib.findLocalTool(NUGET_TOOL_NAME, NUGET_VERSION_4_0_0)) {
        taskLib.debug('Placing bundled NuGet.exe 4.0.0 in tool lib cache');

        let bundledNuGet4Location: string = getBundledNuGet_4_0_0_Location();
        toolLib.cacheFile(bundledNuGet4Location, NUGET_EXE_FILENAME, NUGET_TOOL_NAME, NUGET_VERSION_4_0_0);
    }
}

function GetRestClientOptions(): restm.IRequestOptions
{
    let options: restm.IRequestOptions = <restm.IRequestOptions>{};
    options.responseProcessor = (obj: any) => {
        return obj['nuget.exe'];
    }
    return options;
}

async function getLatestMatchVersionInfo(versionSpec: string): Promise<INuGetVersionInfo> {
    taskLib.debug('Querying versions list');

    let versionsUrl = 'https://dist.nuget.org/tools.json';
    let rest: restm.RestClient = new restm.RestClient('vsts-tasks/NuGetToolInstaller');

    let nugetVersions: INuGetVersionInfo[] = (await rest.get<INuGetVersionInfo[]>(versionsUrl, GetRestClientOptions())).result;
    // x.stage is the string representation of the enum, NuGetReleaseStage.Value = number, NuGetReleaseStage[NuGetReleaseStage.Value] = string, NuGetReleaseStage[x.stage] = number
    let releasedVersions: INuGetVersionInfo[] = nugetVersions.filter(x => x.stage.toString() !== NuGetReleaseStage[NuGetReleaseStage.EarlyAccessPreview]);
    let versionStringsFromDist: string[] = releasedVersions.map(x => x.version);

    let version: string = toolLib.evaluateVersions(versionStringsFromDist, versionSpec);
    if (!version)
    {
        taskLib.error(taskLib.loc("Error_NoVersionWasFoundWhichMatches", versionSpec));
        taskLib.error(taskLib.loc("Info_AvailableVersions", releasedVersions.map(x => x.version).join("; ")));
        throw new Error(taskLib.loc("Error_NuGetToolInstallerFailer", NUGET_TOOL_NAME));
    }

    return releasedVersions.find(x => x.version === version);
}

function getBundledNuGet_4_0_0_Location(): string {
    const nugetPaths: string[] = ['NuGet/4.0.0/'];

    let taskNodeModulesPath: string = path.dirname(__dirname);
    let taskRootPath: string = path.dirname(taskNodeModulesPath);
    const toolPath = commandHelper.locateTool("NuGet",
    <commandHelper.LocateOptions>{
        root: taskRootPath,
        searchPath: nugetPaths,
        toolFilenames: ['NuGet.exe', 'nuget.exe'],
    });

    return toolPath;
}

redpajama_set_name: RedPajamaGithub


text:
import { IFontFamily, ITypographyStyle } from './font';
import { IStringMap, Units } from './index';
import { IProjectContentDocument } from './project';
import { EntityType } from './entity-types';

interface IDesignAttribute {
  id?: string;
  name: string;
  index?: number;
  value: string | number;
}
export interface IDesignColor {
  variants?: string[];
  index?: number;
  name: string;
  value: string;
  hidden?: boolean;
}

export interface IDesignIcon {
  fontId: string;
  name: string;
  source: string;
}

export enum DesignVariableType {
  Layout = 'layout',
  Size = 'size',
  Opacity = 'opacity',
  Custom = 'custom',
  Shadow = 'shadow',
}
export interface IDesignVariable extends IDesignAttribute {
  units?: Units;
  type: DesignVariableType;
}

export interface IDesignSystem {
  themeId?: string; // optionally bound to canonical theme
  colors: IStringMap<IDesignColor>;
  icons: IFontFamily;
  fonts: IStringMap<IFontFamily>;
  typography: IStringMap<ITypographyStyle>;
  variables?: IStringMap<IDesignVariable>;
  globalCssClass?: string | null;
  isDarkTheme?: boolean;
}

export interface IDesignSystemDocument extends IDesignSystem, IProjectContentDocument {
  type: EntityType.DesignSystem;
}

export type DesignSystemMap = Record<string, IDesignSystemDocument>;


text:
(function(root, doc) {

  var Pad, debugMode, selection, utils = {};
  var toString = Object.prototype.toString;
  var slice = Array.prototype.slice;

  // allow command list
  var commandsReg = {
    block: /^(?:p|h[1-6]|blockquote|pre)$/,
    inline: /^(?:bold|italic|underline|insertorderedlist|insertunorderedlist|indent|outdent)$/,
    source: /^(?:createlink|unlink)$/,
    insert: /^(?:inserthorizontalrule|insertimage|insert)$/,
    wrap: /^(?:code)$/
  };

  var lineBreakReg = /^(?:blockquote|pre|div)$/i;

  var effectNodeReg = /(?:[pubia]|h[1-6]|blockquote|[uo]l|li)/i;

  var strReg = {
    whiteSpace: /(^\s+)|(\s+$)/g,
    mailTo: /^(?!mailto:|.+\/|.+#|.+\?)(.*@.*\..+)$/,
    http: /^(?!\w+?:\/\/|mailto:|\/|\.\/|\?|#)(.*)$/
  };

  var autoLinkReg = {
    url: /((https?|ftp):\/\/|www\.)[^\s<]{3,}/gi,
    prefix: /^(?:https?|ftp):\/\//i,
    notLink: /^(?:img|a|input|audio|video|source|code|pre|script|head|title|style)$/i,
    maxLength: 100
  };

  // type detect
  utils.is = function(obj, type) {
    return toString.call(obj).slice(8, -1) === type;
  };

  utils.forEach = function(obj, iterator, arrayLike) {
    if (!obj) return;
    if (arrayLike == null) arrayLike = utils.is(obj, 'Array');
    if (arrayLike) {
      for (var i = 0, l = obj.length; i < l; i++) iterator(obj[i], i, obj);
    } else {
      for (var key in obj) {
        if (obj.hasOwnProperty(key)) iterator(obj[key], key, obj);
      }
    }
  };

  // copy props from a obj
  utils.copy = function(defaults, source) {
    utils.forEach(source, function (value, key) {
      defaults[key] = utils.is(value, 'Object') ? utils.copy({}, value) :
        utils.is(value, 'Array') ? utils.copy([], value) : value;
    });
    return defaults;
  };

  // log
  utils.log = function(message, force) {
    if (debugMode || force)
      console.log('%cPEN DEBUGGER: %c' + message, 'font-family:arial,sans-serif;color:#1abf89;line-height:2em;', 'font-family:cursor,monospace;color:#333;');
  };

  utils.delayExec = function (fn) {
    var timer = null;
    return function (delay) {
      clearTimeout(timer);
      timer = setTimeout(function() {
        fn();
      }, delay || 1);
    };
  };

  // merge: make it easy to have a fallback
  utils.merge = function(config) {

    // default settings
    var defaults = {
      class: 'pad',
      debug: false,
      toolbar: null, // custom toolbar
      stay: config.stay || !config.debug,
      stayMsg: 'Are you going to leave here?',
      textarea: '<textarea name="content"></textarea>',
      list: [
        'blockquote', 'h2', 'h3', 'p', 'code', 'insertorderedlist', 'insertunorderedlist', 'inserthorizontalrule',
        'indent', 'outdent', 'bold', 'italic', 'underline', 'createlink', 'insertimage'
      ],
      cleanAttrs: ['id', 'class', 'style', 'name'],
      cleanTags: ['script']
    };

    // user-friendly config
    if (config.nodeType === 1) {
      defaults.editor = config;
    } else if (config.match && config.match(/^#[\S]+$/)) {
      defaults.editor = doc.getElementById(config.slice(1));
    } else {
      defaults = utils.copy(defaults, config);
    }

    return defaults;
  };

  function commandOverall(ctx, cmd, val) {
    var message = ' to exec 「' + cmd + '」 command' + (val ? (' with value: ' + val) : '');

    try {
      doc.execCommand(cmd, false, val);
    } catch(err) {
      // TODO: there's an error when insert a image to document, bug not a bug
      return utils.log('fail' + message, true);
    }

    utils.log('success' + message);
  }

  function commandInsert(ctx, name, val) {
    var node = getNode(ctx);
    if (!node) return;
    ctx._range.selectNode(node);
    ctx._range.collapse(false);

    // hide menu when a image was inserted
    if(name === 'insertimage' && ctx._menu) toggleNode(ctx._menu, true);

    return commandOverall(ctx, name, val);
  }

  function commandBlock(ctx, name) {
    var list = effectNode(ctx, getNode(ctx), true);
    if (list.indexOf(name) !== -1) name = 'p';
    return commandOverall(ctx, 'formatblock', name);
  }

  function commandWrap(ctx, tag, value) {
    value = '<' + tag + '>' + (value||selection.toString()) + '</' + tag + '>';
    return commandOverall(ctx, 'insertHTML', value);
  }

  function initToolbar(ctx) {
    var icons = '', inputStr = '<input class="pad-input" placeholder="http://" />';

    ctx._toolbar = ctx.config.toolbar;
    if (!ctx._toolbar) {
      var toolList = ctx.config.list;
      utils.forEach(toolList, function (name) {
        var klass = 'pad-icon icon-' + name;
        icons += '';
      }, true);
      if (toolList.indexOf('createlink') >= 0 || toolList.indexOf('createlink') >= 0)
        icons += inputStr;
    } else if (ctx._toolbar.querySelectorAll('[data-action=createlink]').length ||
      ctx._toolbar.querySelectorAll('[data-action=insertimage]').length) {
      icons += inputStr;
    }

    if (icons) {
      ctx._menu = doc.createElement('div');
      ctx._menu.setAttribute('class', ctx.config.class + '-menu pad-menu');
      ctx._menu.innerHTML = icons;
      ctx._inputBar = ctx._menu.querySelector('input');
      toggleNode(ctx._menu, true);
      doc.body.appendChild(ctx._menu);
    }
    if (ctx._toolbar && ctx._inputBar) toggleNode(ctx._inputBar);
  }

  function initEvents(ctx) {
    var toolbar = ctx._toolbar || ctx._menu, editor = ctx.config.editor;

    var toggleMenu = utils.delayExec(function() {
      ctx.highlight().menu();
    });
    var outsideClick = function() {};

    function updateStatus(delay) {
      ctx._range = ctx.getRange();
      toggleMenu(delay);
    }

    if (ctx._menu) {
      var setpos = function() {
        if (ctx._menu.style.display === 'block') ctx.menu();
      };

      // change menu offset when window resize / scroll
      addListener(ctx, root, 'resize', setpos);
      addListener(ctx, root, 'scroll', setpos);

      // toggle toolbar on mouse select
      var selecting = false;
      addListener(ctx, editor, 'mousedown', function() {
        selecting = true;
      });
      addListener(ctx, editor, 'mouseleave', function() {
        if (selecting) updateStatus(800);
        selecting = false;
      });
      addListener(ctx, editor, 'mouseup', function() {
        if (selecting) updateStatus(100);
        selecting = false;
      });
      // Hide menu when focusing outside of editor
      outsideClick = function(e) {
        if (ctx._menu && !containsNode(editor, e.target) && !containsNode(ctx._menu, e.target)) {
          removeListener(ctx, doc, 'click', outsideClick);
          toggleMenu(100);
        }
      };
    } else {
      addListener(ctx, editor, 'click', function() {
        updateStatus(0);
      });
    }

    addListener(ctx, editor, 'keyup', function(e) {
      if (e.which === 8 && ctx.isEmpty()) return lineBreak(ctx, true);
      // toggle toolbar on key select
      if (e.which !== 13 || e.shiftKey) return updateStatus(400);
      var node = getNode(ctx, true);
      if (!node || !node.nextSibling || !lineBreakReg.test(node.nodeName)) return;
      if (node.nodeName !== node.nextSibling.nodeName) return;
      // hack for webkit, make 'enter' behavior like as firefox.
      if (node.lastChild.nodeName !== 'BR') node.appendChild(doc.createElement('br'));
      utils.forEach(node.nextSibling.childNodes, function(child) {
        if (child) node.appendChild(child);
      }, true);
      node.parentNode.removeChild(node.nextSibling);
      focusNode(ctx, node.lastChild, ctx.getRange());
    });

    // check line break
    addListener(ctx, editor, 'keydown', function(e) {
      editor.classList.remove('pad-placeholder');
      if (e.which !== 13 || e.shiftKey) return;
      var node = getNode(ctx, true);
      if (!node || !lineBreakReg.test(node.nodeName)) return;
      var lastChild = node.lastChild;
      if (!lastChild || !lastChild.previousSibling) return;
      if (lastChild.previousSibling.textContent || lastChild.textContent) return;
      // quit block mode for 2 'enter'
      e.preventDefault();
      var p = doc.createElement('p');
      p.innerHTML = '
';
      node.removeChild(lastChild);
      if (!node.nextSibling) node.parentNode.appendChild(p);
      else node.parentNode.insertBefore(p, node.nextSibling);
      focusNode(ctx, p, ctx.getRange());
    });

    var menuApply = function(action, value) {
      ctx.execCommand(action, value);
      ctx._range = ctx.getRange();
      ctx.highlight().menu();
    };

    // toggle toolbar on key select
    addListener(ctx, toolbar, 'click', function(e) {
      var node = e.target, action;

      while (node !== toolbar && !(action = node.getAttribute('data-action'))) {
        node = node.parentNode;
      }

      if (!action) return;
      if (!/(?:createlink)|(?:insertimage)/.test(action)) return menuApply(action);
      if (!ctx._inputBar) return;

      // create link
      var input = ctx._inputBar;
      if (toolbar === ctx._menu) toggleNode(input);
      else {
        ctx._inputActive = true;
        ctx.menu();
      }
      if (ctx._menu.style.display === 'none') return;

      setTimeout(function() { input.focus(); }, 400);
      var createlink = function() {
        var inputValue = input.value;

        if (!inputValue) action = 'unlink';
        else {
          inputValue = input.value
            .replace(strReg.whiteSpace, '')
            .replace(strReg.mailTo, 'mailto:$1')
            .replace(strReg.http, 'http://$1');
        }
        menuApply(action, inputValue);
        if (toolbar === ctx._menu) toggleNode(input, false);
        else toggleNode(ctx._menu, true);
      };

      input.onkeypress = function(e) {
        if (e.which === 13) return createlink();
      };

    });

    // listen for placeholder
    addListener(ctx, editor, 'focus', function() {
      if (ctx.isEmpty()) lineBreak(ctx, true);
      addListener(ctx, doc, 'click', outsideClick);
    });

    addListener(ctx, editor, 'blur', function() {
      checkPlaceholder(ctx);
      ctx.checkContentChange();
    });

    // listen for paste and clear style
    addListener(ctx, editor, 'paste', function() {
      setTimeout(function() {
        ctx.cleanContent();
      });
    });
  }

  function addListener(ctx, target, type, listener) {
    if (ctx._events.hasOwnProperty(type)) {
      ctx._events[type].push(listener);
    } else {
      ctx._eventTargets = ctx._eventTargets || [];
      ctx._eventsCache = ctx._eventsCache || [];
      var index = ctx._eventTargets.indexOf(target);
      if (index < 0) index = ctx._eventTargets.push(target) - 1;
      ctx._eventsCache[index] = ctx._eventsCache[index] || {};
      ctx._eventsCache[index][type] = ctx._eventsCache[index][type] || [];
      ctx._eventsCache[index][type].push(listener);

      target.addEventListener(type, listener, false);
    }
    return ctx;
  }

  // trigger local events
  function triggerListener(ctx, type) {
    if (!ctx._events.hasOwnProperty(type)) return;
    var args = slice.call(arguments, 2);
    utils.forEach(ctx._events[type], function (listener) {
      listener.apply(ctx, args);
    });
  }

  function removeListener(ctx, target, type, listener) {
    var events = ctx._events[type];
    if (!events) {
      var _index = ctx._eventTargets.indexOf(target);
      if (_index >= 0) events = ctx._eventsCache[_index][type];
    }
    if (!events) return ctx;
    var index = events.indexOf(listener);
    if (index >= 0) events.splice(index, 1);
    target.removeEventListener(type, listener, false);
    return ctx;
  }

  function removeAllListeners(ctx) {
    utils.forEach(this._events, function (events) {
      events.length = 0;
    }, false);
    if (!ctx._eventsCache) return ctx;
    utils.forEach(ctx._eventsCache, function (events, index) {
      var target = ctx._eventTargets[index];
      utils.forEach(events, function (listeners, type) {
        utils.forEach(listeners, function (listener) {
          target.removeEventListener(type, listener, false);
        }, true);
      }, false);
    }, true);
    ctx._eventTargets = [];
    ctx._eventsCache = [];
    return ctx;
  }

  function checkPlaceholder(ctx) {
    ctx.config.editor.classList[ctx.isEmpty() ? 'add' : 'remove']('pad-placeholder');
  }

  function trim(str) {
    return (str || '').replace(/^\s+|\s+$/g, '');
  }

  // node.contains is not implemented in IE10/IE11
  function containsNode(parent, child) {
    if (parent === child) return true;
    child = child.parentNode;
    while (child) {
      if (child === parent) return true;
      child = child.parentNode;
    }
    return false;
  }

  function getNode(ctx, byRoot) {
    var node, root = ctx.config.editor;
    ctx._range = ctx._range || ctx.getRange();
    node = ctx._range.commonAncestorContainer;
    if (!node || node === root) return null;
    while (node && (node.nodeType !== 1) && (node.parentNode !== root)) node = node.parentNode;
    while (node && byRoot && (node.parentNode !== root)) node = node.parentNode;
    return containsNode(root, node) ? node : null;
  }

  // node effects
  function effectNode(ctx, el, returnAsNodeName) {
    var nodes = [];
    el = el || ctx.config.editor;
    while (el && el !== ctx.config.editor) {
      if (el.nodeName.match(effectNodeReg)) {
        nodes.push(returnAsNodeName ? el.nodeName.toLowerCase() : el);
      }
      el = el.parentNode;
    }
    return nodes;
  }

  // breakout from node
  function lineBreak(ctx, empty) {
    var range = ctx._range = ctx.getRange(), node = doc.createElement('p');
    if (empty) ctx.config.editor.innerHTML = '';
    node.innerHTML = '
';
    range.insertNode(node);
    focusNode(ctx, node.childNodes[0], range);
  }

  function focusNode(ctx, node, range) {
    range.setStartAfter(node);
    range.setEndBefore(node);
    range.collapse(false);
    ctx.setRange(range);
  }

  function autoLink(node) {
    if (node.nodeType === 1) {
      if (autoLinkReg.notLink.test(node.tagName)) return;
      utils.forEach(node.childNodes, function (child) {
        autoLink(child);
      }, true);
    } else if (node.nodeType === 3) {
      var result = urlToLink(node.nodeValue || '');
      if (!result.links) return;
      var frag = doc.createDocumentFragment(),
        div = doc.createElement('div');
      div.innerHTML = result.text;
      while (div.childNodes.length) frag.appendChild(div.childNodes[0]);
      node.parentNode.replaceChild(frag, node);
    }
  }

  function urlToLink(str) {
    var count = 0;
    str = str.replace(autoLinkReg.url, function(url) {
      var realUrl = url, displayUrl = url;
      count++;
      if (url.length > autoLinkReg.maxLength) displayUrl = url.slice(0, autoLinkReg.maxLength) + '...';
      // Add http prefix if necessary
      if (!autoLinkReg.prefix.test(realUrl)) realUrl = 'http://' + realUrl;
      return '' + displayUrl + '';
    });
    return {links: count, text: str};
  }

  function toggleNode(node, hide) {
    node.style.display = hide ? 'none' : 'block';
  }

  Pad = function(config) {

    if (!config) throw new Error('Can\'t find config');

    debugMode = config.debug;

    // merge user config
    var defaults = utils.merge(config);

    var editor = defaults.editor;

    if (!editor || editor.nodeType !== 1) throw new Error('Can\'t find editor');

    // set default class
    editor.classList.add(defaults.class);

    // set contenteditable
    editor.setAttribute('contenteditable', 'true');

    // assign config
    this.config = defaults;

    // set placeholder
    if (defaults.placeholder) editor.setAttribute('data-placeholder', defaults.placeholder);
    checkPlaceholder(this);

    // save the selection obj
    this.selection = selection;

    // define local events
    this._events = {change: []};

    // enable toolbar
    initToolbar(this);

    // init events
    initEvents(this);

    // to check content change
    this._prevContent = this.getContent();

    // enable markdown covert
    if (this.markdown) this.markdown.init(this);

    // stay on the page
    if (this.config.stay) this.stay(this.config);

  };

  Pad.prototype.on = function(type, listener) {
    addListener(this, this.config.editor, type, listener);
    return this;
  };

  Pad.prototype.isEmpty = function(node) {
    node = node || this.config.editor;
    return !(node.querySelector('img')) && !(node.querySelector('blockquote')) &&
      !(node.querySelector('li')) && !trim(node.textContent);
  };

  Pad.prototype.getContent = function() {
    return this.isEmpty() ?  '' : trim(this.config.editor.innerHTML);
  };

  Pad.prototype.setContent = function(html) {
    this.config.editor.innerHTML = html;
    this.cleanContent();
    return this;
  };

  Pad.prototype.checkContentChange = function () {
    var prevContent = this._prevContent, currentContent = this.getContent();
    if (prevContent === currentContent) return;
    this._prevContent = currentContent;
    triggerListener(this, 'change', currentContent, prevContent);
  };

  Pad.prototype.getRange = function() {
    var editor = this.config.editor, range = selection.rangeCount && selection.getRangeAt(0);
    if (!range) range = doc.createRange();
    if (!containsNode(editor, range.commonAncestorContainer)) {
      range.selectNodeContents(editor);
      range.collapse(false);
    }
    return range;
  };

  Pad.prototype.setRange = function(range) {
    range = range || this._range;
    if (!range) {
      range = this.getRange();
      range.collapse(false); // set to end
    }
    try {
      selection.removeAllRanges();
      selection.addRange(range);
    } catch (e) {/* IE throws error sometimes*/}
    return this;
  };

  Pad.prototype.focus = function(focusStart) {
    if (!focusStart) this.setRange();
    this.config.editor.focus();
    return this;
  };

  Pad.prototype.execCommand = function(name, value) {
    name = name.toLowerCase();
    this.setRange();

    if (commandsReg.block.test(name)) {
      commandBlock(this, name);
    } else if (commandsReg.inline.test(name) || commandsReg.source.test(name)) {
      commandOverall(this, name, value);
    } else if (commandsReg.insert.test(name)) {
      commandInsert(this, name, value);
    } else if (commandsReg.wrap.test(name)) {
      commandWrap(this, name, value);
    } else {
      utils.log('can not find command function for name: ' + name + (value ? (', value: ' + value) : ''), true);
    }
    if (name === 'indent') this.checkContentChange();
    else this.cleanContent({cleanAttrs: ['style']});
  };

  // remove attrs and tags
  // pad.cleanContent({cleanAttrs: ['style'], cleanTags: ['id']})
  Pad.prototype.cleanContent = function(options) {
    var editor = this.config.editor;

    if (!options) options = this.config;
    utils.forEach(options.cleanAttrs, function (attr) {
      utils.forEach(editor.querySelectorAll('[' + attr + ']'), function(item) {
        item.removeAttribute(attr);
      }, true);
    }, true);
    utils.forEach(options.cleanTags, function (tag) {
      utils.forEach(editor.querySelectorAll(tag), function(item) {
        item.parentNode.removeChild(item);
      }, true);
    }, true);

    checkPlaceholder(this);
    this.checkContentChange();
    return this;
  };

  // auto link content, return content
  Pad.prototype.autoLink = function() {
    autoLink(this.config.editor);
    return this.getContent();
  };

  // highlight menu
  Pad.prototype.highlight = function() {
    var toolbar = this._toolbar || this._menu
      , node = getNode(this);
    // remove all highlights
    utils.forEach(toolbar.querySelectorAll('.active'), function(el) {
      el.classList.remove('active');
    }, true);

    if (!node) return this;

    var effects = effectNode(this, node)
      , inputBar = this._inputBar
      , highlight;

    if (inputBar && toolbar === this._menu) {
      // display link input if createlink enabled
      inputBar.style.display = 'none';
      // reset link input value
      inputBar.value = '';
    }

    highlight = function(str) {
      if (!str) return;
      var el = toolbar.querySelector('[data-action=' + str + ']');
      return el && el.classList.add('active');
    };
    utils.forEach(effects, function(item) {
      var tag = item.nodeName.toLowerCase();
      switch(tag) {
        case 'a':
          if (inputBar) inputBar.value = item.getAttribute('href');
          tag = 'createlink';
          break;
        case 'img':
          if (inputBar) inputBar.value = item.getAttribute('src');
          tag = 'insertimage';
          break;
        case 'i':
          tag = 'italic';
          break;
        case 'u':
          tag = 'underline';
          break;
        case 'b':
          tag = 'bold';
          break;
        case 'pre':
        case 'code':
          tag = 'code';
          break;
        case 'ul':
          tag = 'insertunorderedlist';
          break;
        case 'ol':
          tag = 'insertorderedlist';
          break;
        case 'li':
          tag = 'indent';
          break;
      }
      highlight(tag);
    }, true);

    return this;
  };

  // show menu
  Pad.prototype.menu = function() {
    if (!this._menu) return this;
    if (selection.isCollapsed) {
      this._menu.style.display = 'none'; //hide menu
      this._inputActive = false;
      return this;
    }
    if (this._toolbar) {
      if (!this._inputBar || !this._inputActive) return this;
    }
    var offset = this._range.getBoundingClientRect()
      , menuPadding = 10
      , top = offset.top - menuPadding
      , left = offset.left + (offset.width / 2)
      , menu = this._menu
      , menuOffset = {x: 0, y: 0}
      , stylesheet = this._stylesheet;

    // fixes some browser double click visual discontinuity
    // if the offset has no width or height it should not be used
    if (offset.width === 0 && offset.height === 0) return this;

    // store the stylesheet used for positioning the menu horizontally
    if (this._stylesheet === undefined) {
      var style = document.createElement("style");
      document.head.appendChild(style);
      this._stylesheet = stylesheet = style.sheet;
    }
    // display block to caculate its width & height
    menu.style.display = 'block';

    menuOffset.x = left - (menu.clientWidth / 2);
    menuOffset.y = top - menu.clientHeight;

    // check to see if menu has over-extended its bounding box. if it has,
    // 1) apply a new class if overflowed on top;
    // 2) apply a new rule if overflowed on the left
    if (stylesheet.cssRules.length > 0) {
      stylesheet.deleteRule(0);
    }
    if (menuOffset.x < 0) {
      menuOffset.x = 0;
      stylesheet.insertRule('.pad-menu:after {left: ' + left + 'px;}', 0);
    } else {
      stylesheet.insertRule('.pad-menu:after {left: 50%; }', 0);
    }
    if (menuOffset.y < 0) {
      menu.classList.add('pad-menu-below');
      menuOffset.y = offset.top + offset.height + menuPadding;
    } else {
      menu.classList.remove('pad-menu-below');
    }

    menu.style.top = menuOffset.y + 'px';
    menu.style.left = menuOffset.x + 'px';
    return this;
  };

  Pad.prototype.stay = function(config) {
    var ctx = this;
    if (!window.onbeforeunload) {
      window.onbeforeunload = function() {
        if (!ctx._isDestroyed) return config.stayMsg;
      };
    }
  };

  Pad.prototype.destroy = function(isAJoke) {
    var destroy = isAJoke ? false : true
      , attr = isAJoke ? 'setAttribute' : 'removeAttribute';

    if (!isAJoke) {
      removeAllListeners(this);
      try {
        selection.removeAllRanges();
        if (this._menu) this._menu.parentNode.removeChild(this._menu);
      } catch (e) {/* IE throws error sometimes*/}
    } else {
      initToolbar(this);
      initEvents(this);
    }
    this._isDestroyed = destroy;
    this.config.editor[attr]('contenteditable', '');

    return this;
  };

  Pad.prototype.rebuild = function() {
    return this.destroy('it\'s a joke');
  };

  // a fallback for old browers
  root.Pad = function(config) {
    if (!config) return utils.log('can\'t find config', true);

    var defaults = utils.merge(config)
      , klass = defaults.editor.getAttribute('class');

    klass = klass ? klass.replace(/\bpad\b/g, '') + ' pad-textarea ' + defaults.class : 'pad pad-textarea';
    defaults.editor.setAttribute('class', klass);
    defaults.editor.innerHTML = defaults.textarea;
    return defaults.editor;
  };

  // make it accessible
  if (doc.getSelection) {
    selection = doc.getSelection();
    root.Pad = Pad;
  }

}(window, document));


text:
package com.kind.samples.patterns.singleton.impl;

import com.kind.samples.patterns.singleton.Factory;

public class SingletonFactory implements Factory {
    private int count;

    private SingletonFactory() {
    }

    private static class SingletonHandler {
        private static SingletonFactory instance = new SingletonFactory();
    }

    public static SingletonFactory getInstance() {
        return SingletonHandler.instance;
    }

    @Override
    public int getCount() {
        return this.count++;
    }

}


text:
package org.light4j.filter;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;

import java.io.*;

@WebFilter(filterName = "authority", urlPatterns = { "/*" }, initParams = {
		@WebInitParam(name = "encoding", value = "UTF-8"),
		@WebInitParam(name = "loginPage", value = "/login.jsp"),
		@WebInitParam(name = "proLogin", value = "/proLogin.jsp") })
public class AuthorityFilter implements Filter {
	// FilterConfig可用于访问Filter的配置信息
	private FilterConfig config;

	// 实现初始化方法
	public void init(FilterConfig config) {
		this.config = config;
	}

	// 实现销毁方法
	public void destroy() {
		this.config = null;
	}

	// 执行过滤的核心方法
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		// 获取该Filter的配置参数
		String encoding = config.getInitParameter("encoding");
		String loginPage = config.getInitParameter("loginPage");
		String proLogin = config.getInitParameter("proLogin");
		// 设置request编码用的字符集
		request.setCharacterEncoding(encoding); // ①
		HttpServletRequest requ = (HttpServletRequest) request;
		HttpSession session = requ.getSession(true);
		// 获取客户请求的页面
		String requestPath = requ.getServletPath();
		// 如果session范围的user为null,即表明没有登录
		// 且用户请求的既不是登录页面,也不是处理登录的页面
		if (session.getAttribute("user") == null
				&& !requestPath.endsWith(loginPage)
				&& !requestPath.endsWith(proLogin)) {
			// forward到登录页面
			request.setAttribute("tip", "您还没有登录");
			request.getRequestDispatcher(loginPage).forward(request, response);
		}
		// 放行请求
		else {
			chain.doFilter(request, response);
		}
	}
}


text:
void liquid_define_raw(void);

#endif


text:
<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"

	>
<channel>
	<title>Comments on: 2014-2015 Akita Association of JETs Financial Report</title>
	<atom:link href="http://charityakita.com/archive/2015/09/18/2014-2015-akita-association-of-jets-financial-report/feed/" rel="self" type="application/rss+xml" />
	<link>http://charityakita.com/archive/2015/09/18/2014-2015-akita-association-of-jets-financial-report/</link>
	<description>Blog Archive</description>
	<lastBuildDate>Fri, 24 Jul 2015 01:34:07 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>https://wordpress.org/?v=4.5.2</generator>
</channel>
</rss>


text:
package japha;

public class JaphaTest {

    public static void main(String[] args) {
        System.out.println("Just a soluble-japha test file used for tests");
    }

    public static String testStaticReturnString(String str) {
        return str;
    }

    public void testSystemOutPrintln(String str) {
        System.out.println(str);
    }

    public String testThrowException(String str) throws Exception {
        throw new Exception("Always return and exception with string " + str);
    }

}


text:
<?php

namespace CachetHQ\Cachet\Bus\Events\Component;

use CachetHQ\Cachet\Bus\Events\ActionInterface;
use CachetHQ\Cachet\Models\Component;
use CachetHQ\Cachet\Models\User;

/**
 * This is the component status was changed event.
 *
 * @author James Brooks <james@alt-three.com>
 */
final class ComponentStatusWasChangedEvent implements ActionInterface, ComponentEventInterface
{
    /**
     * The user who changed the component.
     *
     * @var \CachetHQ\Cachet\Models\User
     */
    public $user;

    /**
     * The component that was changed.
     *
     * @var \CachetHQ\Cachet\Models\Component
     */
    public $component;

    /**
     * The original status of the component.
     *
     * @var int
     */
    public $original_status;

    /**
     * The new status of the component.
     *
     * @var int
     */
    public $new_status;

    /**
     * If silent, we won't notify.
     *
     * @var bool
     */
    public $silent;

    /**
     * Create a new component was updated event instance.
     *
     * @param \CachetHQ\Cachet\Models\User      $user
     * @param \CachetHQ\Cachet\Models\Component $component
     * @param int                               $original_status
     * @param int                               $new_status
     * @param bool                              $silent
     *
     * @return void
     */
    public function __construct(User $user, Component $component, $original_status, $new_status, $silent)
    {
        $this->user = $user;
        $this->component = $component;
        $this->original_status = $original_status;
        $this->new_status = $new_status;
        $this->silent = $silent;
    }

    /**
     * Get the event description.
     *
     * @return string
     */
    public function __toString()
    {
        return 'Component status was changed.';
    }

    /**
     * Get the event action.
     *
     * @return array
     */
    public function getAction()
    {
        return [
            'user'        => $this->user,
            'description' => (string) $this,
        ];
    }
}


text:
#ifndef __NV40_GRAPH_H__
#define __NV40_GRAPH_H__

/* returns 1 if device is one of the nv4x using the 0x4497 object class,
 * helpful to determine a number of other hardware features
 */
static inline int
nv44_graph_class(void *priv)
{
	struct nouveau_device *device = nv_device(priv);

	if ((device->chipset & 0xf0) == 0x60)
		return 1;

	return !(0x0baf & (1 << (device->chipset & 0x0f)));
}

int  nv40_grctx_init(struct nouveau_device *, u32 *size);
void nv40_grctx_fill(struct nouveau_device *, struct nouveau_gpuobj *);

#endif


text:
<?php

namespace Drupal\tracker\Access;

use Drupal\Core\Access\AccessResult;
use Drupal\Core\Routing\Access\AccessInterface;
use Drupal\Core\Session\AccountInterface;
use Drupal\user\UserInterface;

/**
 * Access check for user tracker routes.
 */
class ViewOwnTrackerAccessCheck implements AccessInterface {

  /**
   * Checks access.
   *
   * @param \Drupal\Core\Session\AccountInterface $account
   *   The currently logged in account.
   * @param \Drupal\user\UserInterface $user
   *   The user whose tracker page is being accessed.
   *
   * @return \Drupal\Core\Access\AccessResultInterface
   *   The access result.
   */
  public function access(AccountInterface $account, UserInterface $user) {
    return AccessResult::allowedIf($user && $account->isAuthenticated() && ($user->id() == $account->id()))->cachePerUser();
  }
}


text:
// ***************************************************************** -*- C++ -*-

/*!
  @file    version.hpp
  @brief   Precompiler define and a function to test the %Exiv2 version.
           References: Similar versioning defines are used in KDE, GTK and other
           libraries. See http://apr.apache.org/versioning.html for accompanying
           guidelines.
  @version $Rev: 2685 $
  @author  Andreas Huggel (ahu)
           ahuggel@gmx.net
  @date    31-May-06, ahu: created
 */
#ifndef VERSION_HPP_
#define VERSION_HPP_

// *****************************************************************************
// included header files
// + standard includes
#include <string>

/*!
  @brief %Exiv2 MAJOR version number of the library used at compile-time.
 */
#define EXIV2_MAJOR_VERSION  (0)
/*!
  @brief %Exiv2 MINOR version number of the library used at compile-time.
 */
#define EXIV2_MINOR_VERSION (23)
/*!
  @brief %Exiv2 PATCH version number of the library used at compile-time.
 */
#define EXIV2_PATCH_VERSION  (0)
/*!
  @brief Make an integer version number for comparison from a major, minor and
         a patch version number.
 */
#define EXIV2_MAKE_VERSION(major,minor,patch) \
    (((major) << 16) | ((minor) << 8) | (patch))
/*!
  @brief The %Exiv2 version number of the library used at compile-time as
         an integer number for easy comparison.
 */
#define EXIV2_VERSION \
    EXIV2_MAKE_VERSION(EXIV2_MAJOR_VERSION,EXIV2_MINOR_VERSION,EXIV2_PATCH_VERSION)
/*!
  @brief Deprecated version check macro. Do not use.

  This macro has flaws and only remains for backward compatibility.
  Use EXIV2_TEST_VERSION and testVersion() instead.
 */
#define EXIV2_CHECK_VERSION(major,minor,patch) \
    ( Exiv2::versionNumber() >= EXIV2_MAKE_VERSION(major,minor,patch) )
/*!
  @brief Macro to test the version of the available %Exiv2 library at compile-time.
         Return true if it is the same as or newer than the passed-in version.

  Versions are denoted using a triplet of integers: \em MAJOR.MINOR.PATCH .

  @code
  // Don't include the <exiv2/version.hpp> file directly, it is included by
  // <exiv2/types.hpp>. Early Exiv2 versions didn't have version.hpp and the macros.

  #include <exiv2/types.hpp>

  // Make sure an EXIV2_TEST_VERSION macro exists:

  #ifdef EXIV2_VERSION
  # ifndef EXIV2_TEST_VERSION
  # define EXIV2_TEST_VERSION(major,minor,patch) \
      ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
  # endif
  #else
  # define EXIV2_TEST_VERSION(major,minor,patch) (false)
  #endif

  std::cout << "Compiled with Exiv2 version " << EXV_PACKAGE_VERSION << "\n"
            << "Runtime Exiv2 version is    " << Exiv2::version()    << "\n";

  // Test the Exiv2 version available at runtime but compile the if-clause only if
  // the compile-time version is at least 0.15. Earlier versions didn't have a
  // testVersion() function:

  #if EXIV2_TEST_VERSION(0,15,0)
  if (Exiv2::testVersion(0,13,0)) {
      std::cout << "Available Exiv2 version is equal to or greater than 0.13\n";
  }
  else {
      std::cout << "Installed Exiv2 version is less than 0.13\n";
  }
  #else
  std::cout << "Compile-time Exiv2 version doesn't have Exiv2::testVersion()\n";
  #endif
  @endcode
 */
#define EXIV2_TEST_VERSION(major,minor,patch) \
    ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )

// *****************************************************************************
// namespace extensions
namespace Exiv2 {
    /*!
      @brief Return the version of %Exiv2 available at runtime as an integer.
    */
    EXIV2API int versionNumber();
    /*!
      @brief Return the version of %Exiv2 as hex string of fixed length 6.
    */
    EXIV2API std::string versionNumberHexString();
    /*!
      @brief Return the version of %Exiv2 available at runtime as a string.
    */
    EXIV2API const char* version();
    /*!
      @brief Test the version of the available %Exiv2 library at runtime. Return
             true if it is the same as or newer than the passed-in version.

      Versions are denoted using a triplet of integers: \em major.minor.patch .

      @code
      // Don't include the <exiv2/version.hpp> file directly, it is included by
      // <exiv2/types.hpp>. Early Exiv2 versions didn't have version.hpp and the macros.

      #include <exiv2/types.hpp>

      // Make sure an EXIV2_TEST_VERSION macro exists:

      #ifdef EXIV2_VERSION
      # ifndef EXIV2_TEST_VERSION
      # define EXIV2_TEST_VERSION(major,minor,patch) \
          ( EXIV2_VERSION >= EXIV2_MAKE_VERSION(major,minor,patch) )
      # endif
      #else
      # define EXIV2_TEST_VERSION(major,minor,patch) (false)
      #endif

      std::cout << "Compiled with Exiv2 version " << EXV_PACKAGE_VERSION << "\n"
                << "Runtime Exiv2 version is    " << Exiv2::version()    << "\n";

      // Test the Exiv2 version available at runtime but compile the if-clause only if
      // the compile-time version is at least 0.15. Earlier versions didn't have a
      // testVersion() function:

      #if EXIV2_TEST_VERSION(0,15,0)
      if (Exiv2::testVersion(0,13,0)) {
          std::cout << "Available Exiv2 version is equal to or greater than 0.13\n";
      }
      else {
          std::cout << "Installed Exiv2 version is less than 0.13\n";
      }
      #else
      std::cout << "Compile-time Exiv2 version doesn't have Exiv2::testVersion()\n";
      #endif
      @endcode
     */
    EXIV2API bool testVersion(int major, int minor, int patch);
}                                       // namespace Exiv2
#endif                                  // VERSION_HPP_


text:
MONO_RUNTIME_ROOT = MONO_ROOT .. "mono/"

function SetupSGen()
	local f = filter()

	defines
	{
		"HAVE_SGEN_GC",
		"HAVE_MOVING_COLLECTOR",
		"HAVE_WRITE_BARRIERS",
		"MONO_DLL_EXPORT"
	}

	files
	{
		MONO_RUNTIME_ROOT .. "metadata/sgen-*.*"
	}

	filter "system:windows"
		files { MONO_RUNTIME_ROOT .. "metadata/sgen-os-win*.c" }

	filter "system:not windows"
		files { MONO_RUNTIME_ROOT .. "metadata/sgen-os-posix.c" }

	filter "system:macosx"
		files { MONO_RUNTIME_ROOT .. "metadata/sgen-os-mach.c" }

	filter(f)
end

function SetupConfigDefines()
	defines
	{
		"HAVE_DECL_INTERLOCKEDCOMPAREEXCHANGE64=1",
		"HAVE_DECL_INTERLOCKEDEXCHANGE64=1",
		"HAVE_DECL_INTERLOCKEDINCREMENT64=1",
		"HAVE_DECL_INTERLOCKEDDECREMENT64=1",
		"HAVE_DECL_INTERLOCKEDADD=1",
		"HAVE_DECL_INTERLOCKEDADD64=1",
		"HAVE_DECL_INTERLOCKEDCOMPAREEXCHANGE64=1",
		"HAVE_DECL___READFSDWORD=1",
	}
end

function GenerateConfig()
	if not os.is("windows") then
		return
	end

	print('Generating Windows config.h')
	os.copyfile(MONO_ROOT .. "winconfig.h", gendir .. "/config.h")
end

function GenerateVersion()
	print('Generating version.h')

	local contents
	if os.isdir(MONO_ROOT .. ".git") then
		local branches = os.outputof("set LANG=C && git branch")
		local branch = string.gmatch(branches, "^\* (%w+)")()
		local version = os.outputof("set LANG=C && git log --no-color --first-parent -n1 --pretty=format:%h")
		contents = string.format("#define FULL_VERSION \"%s/%s\"", branch, version)
	else
		contents = "#define FULL_VERSION \"tarball\""
	end

	file = io.open(path.getabsolute(gendir .. "/version.h"), "w+")
	file:write(contents)
	file:close()
end

function SetupMonoIncludes(monoRuntimeRoot)
	includedirs
	{
		gendir,
		monoRuntimeRoot,
		monoRuntimeRoot .. "..",
		monoRuntimeRoot .. "../eglib/src",
		monoRuntimeRoot .. "utils/",
	}
	print(monoRuntimeRoot .. "../eglib/src")
end

function SetupMonoLinks()
	local f = filter()

	links
	{
		"eglib",
		"libmonoruntime",
		"libmonoutils"
	}

	filter "system:windows"

		links
		{
			"Mswsock",
			"ws2_32",
			"psapi",
			"version",
			"winmm",
		}

	filter()
end

function GenerateMachineDescription(arch)
	local prj = premake.api.scope.project.location
	local abs = path.getabsolute(MONO_RUNTIME_ROOT .. 'mini/cpu-' .. arch .. '.md')
	local input = path.getrelative(prj, abs)
	local out = gendir .. '/cpu-' .. arch .. '.h'
	local desc = arch .. '_desc'

	prebuildcommands
	{
		'"%{cfg.targetdir}/genmdesc" ' .. out .. ' ' .. desc .. ' ' .. input
	}
end

GenerateConfig()
GenerateVersion()

project "mono"

	kind "ConsoleApp"
	language "C"

	files
	{
		MONO_RUNTIME_ROOT .. "mini/main.c",
	}

	includedirs
	{
		gendir,
		MONO_RUNTIME_ROOT .. "../",
		MONO_RUNTIME_ROOT .. "../eglib/src/"
	}

	links
	{
		"eglib",
		"libmono",
		"libmonoruntime",
		"libmonoutils"
	}

	filter "action:vs*"
		defines { "_CRT_SECURE_NO_WARNINGS", "_CRT_NONSTDC_NO_DEPRECATE" }
		SetupConfigDefines()

project "libmono"

	kind "SharedLib"
	language "C"

	defines
	{
		"__default_codegen__",
		"HAVE_CONFIG_H",
		"MONO_DLL_EXPORT"
	}

	SetupMonoIncludes(MONO_RUNTIME_ROOT)
	SetupMonoLinks()

	files
	{
		MONO_RUNTIME_ROOT .. "mini/*.c",
		MONO_RUNTIME_ROOT .. "mini/*.h",
	}

	excludes
	{
		-- Archicture-specific files
		MONO_RUNTIME_ROOT .. "mini/*-alpha.*",
		MONO_RUNTIME_ROOT .. "mini/*-amd64.*",
		MONO_RUNTIME_ROOT .. "mini/*-arm.*",
		MONO_RUNTIME_ROOT .. "mini/*-arm64.*",
		MONO_RUNTIME_ROOT .. "mini/*-hppa.*",
		MONO_RUNTIME_ROOT .. "mini/*-ia64.*",
		MONO_RUNTIME_ROOT .. "mini/*-llvm.*",
		MONO_RUNTIME_ROOT .. "mini/*-mips.*",
		MONO_RUNTIME_ROOT .. "mini/*-ppc.*",
		MONO_RUNTIME_ROOT .. "mini/*-s390*.*",
		MONO_RUNTIME_ROOT .. "mini/*-sparc.*",
		MONO_RUNTIME_ROOT .. "mini/*-x86.*",

		-- Platform-specific files
		MONO_RUNTIME_ROOT .. "mini/*-windows.*",
		MONO_RUNTIME_ROOT .. "mini/*-darwin.*",
		MONO_RUNTIME_ROOT .. "mini/*-posix.*",

		-- Tools
		MONO_RUNTIME_ROOT .. "mini/fsacheck.c",
		MONO_RUNTIME_ROOT .. "mini/genmdesc.c",
		MONO_RUNTIME_ROOT .. "mini/main.c",
	}

	dependson { "genmdesc" }

	filter "platforms:x32"
		GenerateMachineDescription('x86')
		files
		{
			MONO_RUNTIME_ROOT .. "mini/*-x86.c",
		}

	filter "platforms:x64"
		GenerateMachineDescription('amd64')
		files
		{
			MONO_RUNTIME_ROOT .. "mini/*-amd64.c",
		}

	filter "system:windows"
		SetupWindowsDefines()
		files
		{
			MONO_RUNTIME_ROOT .. "mini/*-windows.c"
		}

	filter "system:not windows"
		files
		{
			MONO_RUNTIME_ROOT .. "mini/*-posix.c"
		}

	filter "system:macosx"
		files
		{
			MONO_RUNTIME_ROOT .. "mini/*-darwin.c"
		}

	filter "action:vs*"
		defines { "_CRT_SECURE_NO_WARNINGS", "_CRT_NONSTDC_NO_DEPRECATE" }
		SetupConfigDefines()
		SetupMSVCWarnings()
		buildoptions
		{
			"/wd4018", -- signed/unsigned mismatch
			"/wd4244", -- conversion from 'x' to 'y', possible loss of data
			"/wd4133", -- incompatible types - from 'x *' to 'y *'
			"/wd4715", -- not all control paths return a value
			"/wd4047", -- 'x' differs in levels of indirection from 'y'
		}
		linkoptions
		{
			"/ignore:4049", -- locally defined symbol imported
			"/ignore:4217", -- locally defined symbol imported in function
		}

project "libmonoruntime"

	kind "StaticLib"
	language "C"

	defines
	{
		"HAVE_CONFIG_H",
	}

	SetupMonoIncludes(MONO_RUNTIME_ROOT)

	files
	{
		MONO_RUNTIME_ROOT .. "metadata/*.c",
		MONO_RUNTIME_ROOT .. "metadata/*.h",
		MONO_RUNTIME_ROOT .. "sgen/*.c",
		MONO_RUNTIME_ROOT .. "sgen/*.h",
	}

	excludes
	{
		MONO_RUNTIME_ROOT .. "metadata/threadpool-ms-io-*",

		-- GC-specific files
		MONO_RUNTIME_ROOT .. "metadata/boehm-gc.c",
		MONO_RUNTIME_ROOT .. "metadata/null-gc.c",
		MONO_RUNTIME_ROOT .. "metadata/sgen-*.*",
		MONO_RUNTIME_ROOT .. "metadata/sgen-os-*.*",

		-- Platform-specific files
		MONO_RUNTIME_ROOT .. "metadata/console-unix.c",
		MONO_RUNTIME_ROOT .. "metadata/console-win32.c",
		MONO_RUNTIME_ROOT .. "metadata/coree.c",

		-- Tools
		MONO_RUNTIME_ROOT .. "metadata/monodiet.c",
		MONO_RUNTIME_ROOT .. "metadata/monosn.c",
		MONO_RUNTIME_ROOT .. "metadata/pedump.c",
		MONO_RUNTIME_ROOT .. "metadata/tpool-*.c",
		MONO_RUNTIME_ROOT .. "metadata/test-*.c",
	}

	SetupSGen()

	filter "system:windows"
		SetupWindowsDefines()
		defines { "_WINSOCK_DEPRECATED_NO_WARNINGS" }
		files
		{
			MONO_RUNTIME_ROOT .. "metadata/coree.c",
		}

	filter "system:linux"
		files
		{
			MONO_RUNTIME_ROOT .. "metadata/tpool-epoll.c"
		}

	filter "system:macosx or freebsd"
		files
		{
			MONO_RUNTIME_ROOT .. "metadata/tpool-kqueue.c"
		}

	filter "action:vs*"
		defines { "_CRT_SECURE_NO_WARNINGS", "_CRT_NONSTDC_NO_DEPRECATE" }
		SetupConfigDefines()
		SetupMSVCWarnings()

project "libmonoutils"

	kind "StaticLib"
	language "C"

	defines
	{
		"HAVE_CONFIG_H",
	}

	SetupMonoIncludes(MONO_RUNTIME_ROOT)

	files
	{
		MONO_RUNTIME_ROOT .. "utils/*.c",
		MONO_RUNTIME_ROOT .. "utils/*.h",
	}

	excludes
	{
		MONO_RUNTIME_ROOT .. "utils/sha1.c",

		-- Platform-specific files
		MONO_RUNTIME_ROOT .. "utils/atomic.c",
		MONO_RUNTIME_ROOT .. "utils/mono-hwcap-*.*",
		MONO_RUNTIME_ROOT .. "utils/mono-threads-*.c",

		-- Tools
		MONO_RUNTIME_ROOT .. "utils/mono-embed.c",
	}

	files { MONO_RUNTIME_ROOT .. "utils/mono-threads-state-machine.c" }

	filter "architecture:arm*"
		files { MONO_RUNTIME_ROOT .. "utils/mono-hwcap-arm.*" }

	filter "architecture:x32 or x64"
		files { MONO_RUNTIME_ROOT .. "utils/mono-hwcap-x86.*" }

	filter "system:windows"
		SetupWindowsDefines()
		files
		{
			MONO_RUNTIME_ROOT .. "metadata/coree.c",
			MONO_RUNTIME_ROOT .. "utils/mono-threads-windows.c",
		}
		links
		{
			"Mswsock",
			"ws2_32",
			"psapi",
			"version",
			"winmm",
			"eglib",
		}

	filter "system:not windows"
		files
		{
			MONO_RUNTIME_ROOT .. "utils/mono-threads-posix.c",
		}

	filter "system:macosx"
		files
		{
			MONO_RUNTIME_ROOT .. "utils/mono-threads-mach.c",
		}

	filter "action:vs*"
		defines { "_CRT_SECURE_NO_WARNINGS", "_CRT_NONSTDC_NO_DEPRECATE" }
		SetupConfigDefines()
		SetupMSVCWarnings()
		buildoptions { "/wd4273", "/wd4197" }


text:
package com.emistoolbox.lib.data;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PushbackReader;
import java.util.ArrayList;
import java.util.List;

// This is derived from some old code I had and may have some functionality that we don't need here
public class Table {
	public List<List<String>> rows = new ArrayList<List<String>> ();
	List<String> labels;
	String filename;

	public void readCSV (String file) throws IOException {
		readCSV (file,',');
	}

	public void readCSV (String file,char delimiter) throws IOException {
		setFilename (file);
		List<String> row = null;
		PushbackReader in = new PushbackReader (new FileReader (file));
		StringBuilder builder = null;
		int ncolumns = -1;
		boolean inQuote = false;
		boolean rowEmpty = true;

		try {
			for (;;) {
				int c = in.read ();
				if (c < 0) {
					if (row == null)
						break;
					if (row.size () == ncolumns) {
						rows.add (row);
						break;
					}
				}
				if (c == '#' && row == null) {
					while (c != '\n' && c != '\r')
						c = in.read ();
				}
				if (row == null) {
					if (c == '\n' || c == '\r')
						continue;
					row = new ArrayList<String> ();
					builder = new StringBuilder ();
				}
				if (inQuote) {
					if (c == '"') {
						c = in.read ();
						if (c != '"') {
							if (c >= 0)
								in.unread (c);
							inQuote = false;
							continue;
						}
					}
				}
				else {
					if (c < 0)
						c = '\n';
					if (c != '\n' && c != '\r')
						rowEmpty = false;
					switch (c) {
					case '"' :
						inQuote = true;
						continue;
					case '\n':
					case '\r':
						if (rowEmpty)
							continue;
						row.add (builder.toString ());
						if (ncolumns < 0)
							ncolumns = row.size ();
						else if (row.size () != ncolumns)
							throw new Error ("varying column count : " + row);
						rows.add (row);
						row = null;
						rowEmpty = true;
						continue;
					default:
					    if (c == delimiter) {
					    	row.add (builder.toString ());
					    	builder = new StringBuilder ();
					    	continue;
					    }
					}
				}
				builder.append ((char) c);
			}
		} finally {
			in.close ();
		}
	}

	public void writeCSV (String file) throws IOException {
		FileWriter writer = new FileWriter (file);
		boolean firstRow = true;

		for (List<String> row : rows) {
			if (firstRow)
				firstRow = false;
			else
				writer.write ('\n');
			boolean first = true;
			for (String entry : row) {
				if (first)
					first = false;
				else
					writer.write (',');
				if (entry.indexOf (',') < 0 && entry.indexOf ('\n') < 0 && entry.indexOf ('"') < 0)
					writer.write (entry);
				else {
					writer.write ('"');
					writer.write (entry.replace ("\"","\"\""));
					writer.write ('"');
				}
			}
		}

		writer.close ();
	}

	private int [] getIndices (Table table) {
		return getIndices (table.labels);
	}

	private int [] getIndices (List<String> labels) {
		List<String> myLabels = labels;
		int [] indices = new int [labels.size ()];
		for (int i = 0;i < indices.length;i++) {
			indices [i] = myLabels.indexOf (labels.get (i));
			if (indices [i] < 0) {
				System.out.println ("can't find label '" + labels.get (i) + "' in labels " + myLabels);
				throw new Error ();
			}
		}
		return indices;
	}

	private int [] getIndices (String ... labels) {
		List<String> myLabels = this.labels;
		int [] indices = new int [labels.length];
		for (int i = 0;i < indices.length;i++) {
			indices [i] = myLabels.indexOf (labels [i]);
			if (indices [i] < 0) {
				System.out.println ("can't find label '" + labels [i] + "' in labels " + myLabels);
				throw new Error ();
			}
		}
		return indices;
	}

	public int getIndex (String label) {
		return getIndices (label) [0];
	}

	public int getRowCount () {
		return rows.size ();
	}

	public int getColumnCount () {
		return rows.isEmpty () ? 0 : rows.get (0).size ();
	}

	public Table select (String ... labels) {
		return select (getIndices (labels));
	}

	public Table select (List<String> labels) {
		return select (getIndices (labels));
	}

	public Table select (int ... indices) {
		Table table = new Table ();
		for (List<String> row : rows) {
			List<String> newRow = new ArrayList<String> ();
			for (int j : indices)
				newRow.add (row.get (j));
			table.rows.add (newRow);
		}
		table.setFilename (filename);
		return table;
	}

	public void setLabelRowIndex (int labelRowIndex) {
		labels = rows.get (labelRowIndex);
		while (labelRowIndex-- >= 0)
			rows.remove (0);
	}

	public void normalise () {
		for (List<String> row : rows)
			for (int j = 0;j < row.size ();j++)
				row.set (j,normaliseCase (row.get (j)).trim ());
	}

	static String normaliseCase (String s) {
		char [] chars = s.toCharArray ();
		boolean wasLetter = false;
		for (int i = 0;i < chars.length;i++) {
			boolean isLetter = Character.isLetter (chars [i]);
			if (wasLetter && isLetter)
				chars [i] = Character.toLowerCase (chars [i]);
			wasLetter = isLetter;
		}
		return new String (chars);
	}

	public String getFilename () {
		return filename;
	}

	public void setFilename (String filename) {
		this.filename = filename;
	}
}


text:
html,body{margin:0;padding:0}

body{font: 85% arial,sans-serif}

/* p{margin:0 10px 10px} */

/* a{color: green} */ /* 006 */

div#header{position:relative}

/*
div#header h1{
  height:70px;
  line-height:70px;
  margin:0;
  padding-left:10px;
  background: #EEE;
  color: #79B30B}
*/

div#header h4{
  margin:0;
  padding-left:10px;
  background: #EEE;
  a{color: green}
}

div#header a {
  /* color: green; */

}

a.menuitem:link {color: blue}
a.menuitem:active {color: blue}
a.menuitem:visited {color: blue}
a.menuitem:hover {color: blue}

a.menuitemselected:link {color: red}
a.menuitemselected:active {color: red}
a.menuitemselected:visited {color: red}
a.menuitemselected:hover {color: red}

a.attention:link {color: orange}
a.attention:active {color: orange}
a.attention:visited {color: orange}
a.attention:hover {color: orange}

/* div#header a{background: #EEE;height:80px}  */

/* div#content p{line-height:1.4} */

div#content
{
  background-color: white;
  /* padding-left: 10px; */
}
div#content p{
 padding-left: 10px
}
div#content h3{
  padding-left: 5px;
}

div#dealform{
  background:#B9CAFF;
  float:left;
  width:40%;

}

/* div#dealform{float:left;width:50%} */

div#suggestions{background:#FF8539}
div#suggestions{float:left;width:59.9%}

div#footer{background: #333;color: #FFF}

/* div#footer p{margin:0 0 0 0;padding:5px 10px} */

div#footer a{display:inline;padding:0;color: #C6D5FD}
div#footer{clear:left;width:100%}

/* .pbox {
    /* border: 2px solid #73a1ca; */
    margin-left:20px;
    border-collapse: collapse;
    /*margin: 0 5px 10px 5px;*/
    /*width: 285px;
    padding: 5px;
    float: left;*/
} */

/*

.dealform { margin: 0px; padding: 0px; }
.dealform table { border-collapse: collapse;  }
.dealform td { white-space: nowrap; }
.dealform input.logtxt { color:black; width: 135px}
.dealform td.right { text-align: right}
.dealform button.btn { margin: 0px; padding: 2px 3px 2px 3px}
.dealform a { padding-left: 1em }

*/

.iform button {background-color:#e9e9e9; border: 1px solid #336699; vertical-align: bottom}
.btn { background-color:#e9e9e9;
       border: 1px solid #336699;
       margin: 0 5px 0 5px; vertical-align: bottom }


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>Purdue ROV | BattleStation</title>

    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link rel="stylesheet" href=".build.css">
    <link rel="stylesheet" href="assets/reset.css">
    <link rel="stylesheet" href="assets/main.css">


text:
var React = require('react');

var ReactBootstrap = require('react-bootstrap');
var Grid = ReactBootstrap.Grid;
var Row = ReactBootstrap.Row;
var Col = ReactBootstrap.Col;
var Panel = ReactBootstrap.Panel;
var Alert = ReactBootstrap.Alert;
var Button = ReactBootstrap.Button;
var Input = ReactBootstrap.Input;

var ModalProgressTrigger = require('../modal/ModalProgressTrigger.js');
var FormMixin = require('./FormMixin.js');

var ApplicationActions = require('../../action/application/ApplicationActions.js');

var FormSignUp = React.createClass({

    mixins: [FormMixin],

    componentDidMount: function(){
        this._hideModalProgress();
    },

    getDefaultProps: function () {
        return {
            errors: null
        };
    },

    componentDidUpdate: function(){
        this._hideModalProgress();
    },

    render: function(){
        var panelTitle = (

Create new account

        );
        var alert = null;
        if(this.props.errors && this.props.errors.length > 0){
            var alerts = [];
            for(var i = 0; i < this.props.errors.length; i++){
                alerts.push(

{this.props.errors[i]}

                );
            }
            alert = (
                <Alert bsStyle="danger">{alerts}</Alert>
            );
        }
        return (
            <Grid fluent={true}>
                <Row style={{marginTop: '70px'}}>
                    <Col xs={10} md={8} sm={10} lg={6} xsOffset={1} mdOffset={2} smOffset={1} lgOffset={3}>
                        {alert}
                        <Panel header={panelTitle} bsStyle="primary">
                            <form action='#' onSubmit={this._handleSubmit}>

                                    <Input
                                        type="text"
                                        value={this.props.login}
                                        placeholder="Enter user name"
                                        label="User name"
                                        hasFeedback
                                        ref="userNameInput"
                                        style={{width: '100%'}} />

                                    <Input
                                        type="password"
                                        label="Password"
                                        ref="userPwdInput"
                                        style={{width: '100%'}} />

                                    <Input
                                        type="text"
                                        value={this.props.email}
                                        placeholder="Enter email address"
                                        label="Email address"
                                        ref="userEmailInput"
                                        style={{width: '100%'}} />

                                    <Input
                                        type="checkbox"
                                        ref="rememberInput"
                                        label="Remember me" />

                                    <Button bsStyle='default' onClick={this._handleCancel}>Cancel</Button>
                                    <Button type='submit' bsStyle='primary'>Create</Button>

                            </form>
                        </Panel>
                    </Col>
                </Row>
            </Grid>
        );
    },

    _handleSubmit: function(e){
        e.preventDefault();
        e.stopPropagation();
        this._showModalProgress('Creating user profile. Please wait ...', 400);
        ApplicationActions.createUserProfile({
            user: this.refs.userNameInput.getValue(),
            pass: this.refs.userPwdInput.getValue(),
            email: this.refs.userEmailInput.getValue(),
            remember: this.refs.rememberInput.getChecked()
        });
    },

    _handleCancel: function(e){
        e.preventDefault();
        e.stopPropagation();
        ApplicationActions.goToSignInForm();
    }

});

module.exports = FormSignUp;


text:
<title>Ada Tasks - Debugging with GDB</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Debugging with GDB">
<meta name="generator" content="makeinfo 4.11">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Ada.html#Ada" title="Ada">
<link rel="prev" href="Stopping-Before-Main-Program.html#Stopping-Before-Main-Program" title="Stopping Before Main Program">
<link rel="next" href="Ada-Tasks-and-Core-Files.html#Ada-Tasks-and-Core-Files" title="Ada Tasks and Core Files">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">

<meta http-equiv="Content-Style-Type" content="text/css">

Next: Ada Tasks and Core Files,
Previous: Stopping Before Main Program,
Up: Ada

15.4.8.5 Extensions for Ada Tasks

Support for Ada tasks is analogous to that for threads (see Threads).
gdb provides the following task-related commands:

info tasks
This command shows a list of current Ada tasks, as in the following example:

          (gdb) info tasks
            ID       TID P-ID Pri State                 Name
             1   8088000   0   15 Child Activation Wait main_task
             2   80a4000   1   15 Accept Statement      b
             3   809a800   1   15 Child Activation Wait a
          *  4   80ae800   3   15 Runnable              c

In this listing, the asterisk before the last task indicates it to be the
task currently being inspected.

ID
Represents gdb's internal task number.

TID
The Ada task ID.

P-ID
The parent's task ID (gdb's internal task number).

Pri
The base priority of the task.

State
Current state of the task.

Unactivated
The task has been created but has not been activated.  It cannot be
executing.

Runnable
The task is not blocked for any reason known to Ada.  (It may be waiting
for a mutex, though.) It is conceptually "executing" in normal mode.

Terminated
The task is terminated, in the sense of ARM 9.3 (5).  Any dependents
that were waiting on terminate alternatives have been awakened and have
terminated themselves.

Child Activation Wait
The task is waiting for created tasks to complete activation.

Accept Statement
The task is waiting on an accept or selective wait statement.

Waiting on entry call
The task is waiting on an entry call.

Async Select Wait
The task is waiting to start the abortable part of an asynchronous
select statement.

Delay Sleep
The task is waiting on a select statement with only a delay
alternative open.

Child Termination Wait
The task is sleeping having completed a master within itself, and is
waiting for the tasks dependent on that master to become terminated or
waiting on a terminate Phase.

Wait Child in Term Alt
The task is sleeping waiting for tasks on terminate alternatives to
finish terminating.

Accepting RV with <var>taskno</var>
The task is accepting a rendez-vous with the task <var>taskno</var>.

Name
Name of the task in the program.

info task <var>taskno</var>
This command shows detailled informations on the specified task, as in
the following example:

          (gdb) info tasks
            ID       TID P-ID Pri State                  Name
             1   8077880    0  15 Child Activation Wait  main_task
          *  2   807c468    1  15 Runnable               task_1
          (gdb) info task 2
          Ada Task: 0x807c468
          Name: task_1
          Thread: 0x807f378
          Parent: 1 (main_task)
          Base Priority: 15
          State: Runnable

task
This command prints the ID of the current task.

          (gdb) info tasks
            ID       TID P-ID Pri State                  Name
             1   8077870    0  15 Child Activation Wait  main_task
          *  2   807c458    1  15 Runnable               t
          (gdb) task
          [Current task is 2]

task <var>taskno</var>
This command is like the thread <var>threadno</var>
command (see Threads).  It switches the context of debugging
from the current task to the given task.

          (gdb) info tasks
            ID       TID P-ID Pri State                  Name
             1   8077870    0  15 Child Activation Wait  main_task
          *  2   807c458    1  15 Runnable               t
          (gdb) task 1
          [Switching to task 1]
          #0  0x8067726 in pthread_cond_wait ()
          (gdb) bt
          #0  0x8067726 in pthread_cond_wait ()
          #1  0x8056714 in system.os_interface.pthread_cond_wait ()
          #2  0x805cb63 in system.task_primitives.operations.sleep ()
          #3  0x806153e in system.tasking.stages.activate_tasks ()
          #4  0x804aacc in un () at un.adb:5

break <var>linespec</var> task <var>taskno</var>
break <var>linespec</var> task <var>taskno</var> if ...
These commands are like the break ... thread ...
command (see Thread Stops).
<var>linespec</var> specifies source lines, as described
in Specify Location.

Use the qualifier ‘<samp>task <var>taskno</var></samp>’ with a breakpoint command
to specify that you only want gdb to stop the program when a
particular Ada task reaches this breakpoint.  <var>taskno</var> is one of the
numeric task identifiers assigned by gdb, shown in the first
column of the ‘<samp>info tasks</samp>’ display.

If you do not specify ‘<samp>task <var>taskno</var></samp>’ when you set a
breakpoint, the breakpoint applies to all tasks of your
program.

You can use the task qualifier on conditional breakpoints as
well; in this case, place ‘<samp>task <var>taskno</var></samp>’ before the
breakpoint condition (before the if).

For example,

          (gdb) info tasks
            ID       TID P-ID Pri State                 Name
             1 140022020   0   15 Child Activation Wait main_task
             2 140045060   1   15 Accept/Select Wait    t2
             3 140044840   1   15 Runnable              t1
          *  4 140056040   1   15 Runnable              t3
          (gdb) b 15 task 2
          Breakpoint 5 at 0x120044cb0: file test_task_debug.adb, line 15.
          (gdb) cont
          Continuing.
          task # 1 running
          task # 2 running

          Breakpoint 5, test_task_debug () at test_task_debug.adb:15
          15               flush;
          (gdb) info tasks
            ID       TID P-ID Pri State                 Name
             1 140022020   0   15 Child Activation Wait main_task
          *  2 140045060   1   15 Runnable              t2
             3 140044840   1   15 Runnable              t1
             4 140056040   1   15 Delay Sleep           t3


text:
package Integracion;

import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class Correo {

	 public static String Username = "thewatsonavengers@gmail.com";

	    public static String PassWord = "proyecto1";

	    //String To = "suramirez92@gmail.com";

	    public String SendMail(String pTo, String pSubject, String pMensaje) {
	        Properties props = new Properties();
	        props.put("mail.smtp.auth", "true");
	        props.put("mail.smtp.starttls.enable", "true");
	        props.put("mail.smtp.host", "smtp.gmail.com");
	        props.put("mail.smtp.port", "587");

	        Session session = Session.getInstance(props,
	                new javax.mail.Authenticator() {
	                    protected PasswordAuthentication getPasswordAuthentication() {
	                        return new PasswordAuthentication(Username, PassWord);
	                    }
	                });

	        try {

	            Message message = new MimeMessage(session);
	            message.setFrom(new InternetAddress(Username));
	            message.setRecipients(Message.RecipientType.TO,
	                    InternetAddress.parse(pTo));
	            message.setSubject(pSubject);

	            message.setText(pMensaje);

	            Transport.send(message);
	            return  "Su mensaje ha sido enviado";

	        } catch (MessagingException e) {
	            throw new RuntimeException(e);
	        }
	    }

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Correo nuevo= new Correo();

	}

}


text:
#include "vrpn_Tracker_isense.h"

#ifdef  VRPN_INCLUDE_INTERSENSE
#include <time.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>

#ifdef linux
#include <termios.h>
#endif

#ifndef _WIN32
#include <sys/ioctl.h>
#include <sys/time.h>
#include <unistd.h>
#include <netinet/in.h>
#endif

#include "vrpn_Tracker.h"
#include "vrpn_Serial.h"
#include "vrpn_Shared.h"
#include "vrpn_MessageMacros.h"         // for VRPN_MSG_INFO, VRPN_MSG_WARNING, VRPN_MSG_ERROR
#include "quat.h"
#include "isense.c"

#define MAX_TIME_INTERVAL       (5000000) // max time between reports (usec)
#define	INCHES_TO_METERS	(2.54/100.0)
#define PI (3.14159265358979323846)
#define DEG_TO_RAD (PI/180.)

void vrpn_Tracker_InterSense::getTrackerInfo(char *msg)
{
	sprintf(msg, "Port%d (Intersense lib %g) (Firmware Rev %g)", m_TrackerInfo.Port, m_TrackerInfo.LibVersion, m_TrackerInfo.FirmwareRev);
	switch(m_TrackerInfo.TrackerType) {
		case ISD_NONE:
			sprintf(msg, "%s (Unknown series:", msg);
			break;
		case ISD_PRECISION_SERIES:
			sprintf(msg, "%s (Precision series:", msg);
			break;
		case ISD_INTERTRAX_SERIES:
			sprintf(msg, "%s (InterTrax series:", msg);
			break;
	}
	switch(m_TrackerInfo.TrackerModel) {
		case ISD_UNKNOWN:
			sprintf(msg, "%s Unknown model)", msg);
			break;

		case ISD_IS300:
			sprintf(msg, "%s IS300)", msg);
			break;

		case ISD_IS600:
			sprintf(msg, "%s IS600)", msg);
			break;

		case ISD_IS900:
			sprintf(msg, "%s IS900)", msg);
			break;

		case ISD_IS1200:
			sprintf(msg, "%s IS1200)", msg);
			break;

		case ISD_INTERTRAX:
			sprintf(msg, "%s InterTrax)", msg);
			break;

		case ISD_INTERTRAX_2:
			sprintf(msg, "%s InterTrax2)", msg);
			break;

		case ISD_INTERTRAX_LS:
			sprintf(msg, "%s InterTrax LS)", msg);
			break;

		case ISD_INTERTRAX_LC:
			sprintf(msg, "%s InterTrax LC)", msg);
			break;

		case ISD_ICUBE2:
			sprintf(msg, "%s InertiaCube2)", msg);
			break;

		case ISD_ICUBE2_PRO:
			sprintf(msg, "%s InertiaCube2 Pro)", msg);
			break;

		case ISD_ICUBE3:
			sprintf(msg, "%s InertiaCube3)", msg);
			break;
	}
	sprintf(msg, "%s\n", msg);
}

vrpn_Tracker_InterSense::vrpn_Tracker_InterSense(const char *name,
                                         vrpn_Connection *c,
                                         int commPort, const char *additional_reset_commands,
										 int is900_timestamps, int reset_at_start) :
vrpn_Tracker(name,c), do_is900_timestamps(is900_timestamps),
m_reset_at_start(reset_at_start)
{
#ifdef  VRPN_INCLUDE_INTERSENSE
  char errStr[1024];
  int i;

  register_server_handlers();

	if (additional_reset_commands == NULL) {
		sprintf(add_reset_cmd, "");
	} else {
		strncpy(add_reset_cmd, additional_reset_commands, sizeof(add_reset_cmd)-1);
	}

	// Initially, set to no buttons or analogs on the stations.  The
	// methods to add buttons and analogs must be called to add them.
	for (i = 0; i < ISD_MAX_STATIONS; i++) {
	    is900_buttons[i] = NULL;
	    is900_analogs[i] = NULL;
	}

  m_CommPort = commPort;
  m_Handle = ISD_OpenTracker(NULL, commPort, FALSE, FALSE);

  if(m_Handle == -1)
  {
    sprintf(errStr,"Failed to open tracker '%s' on COM%d: ISLIB_OpenTracker returned -1",name,commPort);
    status = vrpn_TRACKER_FAIL;
    return;
  }

  //  ISD_TRACKER_INFO_TYPE trackerInfo;

  ISD_GetTrackerConfig(m_Handle,&m_TrackerInfo,FALSE);

  for (i = 0; i < ISD_MAX_STATIONS; i++) {
       if (set_sensor_output_format(i)) {
		    sprintf(errStr,"Failed to reset sensor %d on tracker '%s' on COM%d",i, name,commPort);
			status = vrpn_TRACKER_FAIL;
     		return;
       }
  }

  //what is the update rate of this tracker?
  //we might want to set the update rate of the mainloop to based on this value.
  //for now we just print it out.
  getTrackerInfo(errStr);
  vrpn_gettimeofday(&timestamp, NULL);
  VRPN_MSG_INFO(errStr);
  fprintf(stderr,errStr);

  status =   vrpn_TRACKER_SYNCING;
#else
  fprintf(stderr,"Intersense library not compiled into this version.  Use Fastrak driver for IS-600/900 or recompile with VRPN_INCLUDE_INTERSENSE defined\n");
  status = vrpn_TRACKER_FAIL;
#endif
}

vrpn_Tracker_InterSense::~vrpn_Tracker_InterSense()
{
#ifdef  VRPN_INCLUDE_INTERSENSE

    int i;

    ISD_CloseTracker(m_Handle);

    // Delete any button and analog devices that were created
    for (i = 0; i < ISD_MAX_STATIONS; i++) {
		if (is900_buttons[i]) {
		    delete is900_buttons[i];
                    is900_buttons[i] = NULL;
		}
		if (is900_analogs[i]) {
			delete is900_analogs[i];
                        is900_analogs[i] = NULL;
		}
    }
#endif
}

/** This routine augments the basic sensor-output setting function of the Intersense
    to allow the possibility of requesting timestamp, button data, and/or analog
    data from the device.  It sets the device for position + quaternion + any of
    the extended fields.

    Returns 0 on success and -1 on failure.
*/

int vrpn_Tracker_InterSense::set_sensor_output_format(int station)
{
  char errStr[1024];

		//Get the info about the station
        ISD_GetStationConfig(m_Handle,&m_StationInfo[station],station+1,0);

    	//ISD_ResetHeading(m_Handle,station+1); //Not sure if this is needed
		// nahon@virtools.com -
		if (m_reset_at_start)
		  ISD_Boresight(m_Handle, station+1, true); // equivalent to ISD_ResetHeading for itrax, see isense.h

	    // First, try to set the orientation reporting format to quaternions if possible.
		// But, some models of intersense trackers (like the intertrax series) will only report
		// in euler angles

	    // Try to set the tracker to report in quaternion format
		// (to avoid gimbal lock)
		// nahon@virtools.com : Let's try, even if we are not a precision series
		// It seems that this is OK with Intertrax2, what would happen to old Intertrax ?
//		if (m_TrackerInfo.TrackerType == ISD_PRECISION_SERIES &&
		if (
			m_StationInfo[station].AngleFormat == ISD_EULER)
	    {
			m_StationInfo[station].AngleFormat = ISD_QUATERNION;
			if(!ISD_SetStationConfig(m_Handle,&m_StationInfo[station],station+1,FALSE))
		    {
				sprintf(errStr,"Warning: Your tracker doesn't seem to support the quaternion format - couldn't set station config for Station%d. ",station+1);
				vrpn_gettimeofday(&timestamp, NULL);
				VRPN_MSG_WARNING(errStr);

				m_StationInfo[station].AngleFormat = ISD_EULER;
			}
		}

		// do is900 special things
	    // IS900 states (timestamp, button, analog).
		if(m_TrackerInfo.TrackerModel == ISD_IS900) {
			if (do_is900_timestamps) {
				m_StationInfo[station].TimeStamped = TRUE;
				if(!ISD_SetStationConfig(m_Handle,&m_StationInfo[station],station+1,FALSE))
			    {
					sprintf(errStr,"Warning: Your tracker doesn't seem to support the IS900 timestamps - couldn't set station config for Station%d. ",station+1);
					vrpn_gettimeofday(&timestamp, NULL);
					VRPN_MSG_WARNING(errStr);
					m_StationInfo[station].TimeStamped = FALSE;
				}
			}

			if (is900_buttons[station] || is900_analogs[station]) {
				m_StationInfo[station].GetInputs = TRUE;
				if(!ISD_SetStationConfig(m_Handle,&m_StationInfo[station],station+1,FALSE))
			    {
					sprintf(errStr,"Warning: Your tracker doesn't seem to support the IS900 buttons/analogs - couldn't set station config for Station%d. ",station+1);
					vrpn_gettimeofday(&timestamp, NULL);
					VRPN_MSG_WARNING(errStr);
					m_StationInfo[station].GetInputs = FALSE;
				}
			}
		}
		return 0;
}

void vrpn_Tracker_InterSense::reset()
{
#ifdef  VRPN_INCLUDE_INTERSENSE
  char errStr[1024];
  int i;

  m_Handle = ISD_OpenTracker(NULL,m_CommPort,FALSE,FALSE);

  if(m_Handle == -1)
  {
    sprintf(errStr,"InterSense: Failed to open tracker '%s' on COM%d: ISD_OpenTracker returned -1",d_servicename,m_CommPort);
    fprintf(stderr,errStr);
    vrpn_gettimeofday(&timestamp, NULL);
	VRPN_MSG_ERROR(errStr);

    status = vrpn_TRACKER_FAIL;
  }
  else
  {

    //--------------------------------------------------------------------
    // Now that the tracker has given a valid status report, set all of
    // the parameters the way we want them. We rely on power-up setting
    // based on the receiver select switches to turn on the receivers that
    // the user wants.
    //--------------------------------------------------------------------

    // Set output format for each of the possible stations.

    for (i = 0; i < ISD_MAX_STATIONS; i++) {
       if (set_sensor_output_format(i)) {
		   return;
       }
    }

    // Send the additional reset commands, if any, to the tracker.
    // These commands come in lines, with character \015 ending each
    // line.
    if (strlen(add_reset_cmd) > 0) {
		printf("  Intersense writing extended reset commands...\n");
		if(!ISD_SendScript(m_Handle,add_reset_cmd))
	    {
			sprintf(errStr,"Warning: Your tracker failed executing the additional command string. ");
			vrpn_gettimeofday(&timestamp, NULL);
			VRPN_MSG_WARNING(errStr);
		}
	}

    // If we are using the IS-900 timestamps, clear the timer on the device and
    // store the time when we cleared it.  First, drain any characters in the output
    // buffer to ensure we're sending right away.  Then, send the reset command and
    // store the time that we sent it, plus the estimated time for the characters to
    // get across the serial line to the device at the current baud rate.
    // Set time units to milliseconds (MT) and reset the time (MZ).
    if (do_is900_timestamps) {
    	char	clear_timestamp_cmd[] = "MT\015MZ\015";
		if(!ISD_SendScript(m_Handle,clear_timestamp_cmd))
	    {
			sprintf(errStr,"Warning: Your tracker failed executing the additional command string. ");
			vrpn_gettimeofday(&timestamp, NULL);
			VRPN_MSG_WARNING(errStr);
		}

		vrpn_gettimeofday(&is900_zerotime, NULL);
    }

    // Done with reset.
    vrpn_gettimeofday(&timestamp, NULL);	// Set watchdog now
    VRPN_MSG_WARNING("Reset Completed (this is good)");

    status = vrpn_TRACKER_SYNCING;	// We're trying for a new reading
  }
#else
  fprintf(stderr,"Intersense library not compiled into this version.  Use Fastrak driver for IS-600/900 or recompile with VRPN_INCLUDE_INTERSENSE defined\n");
  status = vrpn_TRACKER_FAIL;
#endif
}

// This function will get the reports from the intersense dll, then
// put that report into the time, sensor, pos and quat fields, and
// finally call send_report to send it.
void vrpn_Tracker_InterSense::get_report(void)
{
#ifdef  VRPN_INCLUDE_INTERSENSE
  q_vec_type angles;
  ISD_TRACKING_DATA_TYPE data;
  int i;

  if(ISD_GetTrackingData(m_Handle,&data)) {
    for(int station=0;station<ISD_MAX_STATIONS;station++) {
      if(data.Station[station].NewData == TRUE) {

       d_sensor = station;

        //--------------------------------------------------------------------
		// If we are doing IS900 timestamps, decode the time, add it to the
        // time we zeroed the tracker, and update the report time.  Remember
        // to convert the MILLIseconds from the report into MICROseconds and
        // seconds.
        //--------------------------------------------------------------------

        if (do_is900_timestamps) {
          vrpn_float32 read_time = data.Station[station].TimeStamp;

          struct timeval delta_time;   // Time since the clock was reset

          // Convert from the float in MILLIseconds to the struct timeval
          delta_time.tv_sec = (long)(read_time / 1000);	// Integer trunction to seconds
          read_time -= delta_time.tv_sec * 1000;	// Subtract out what we just counted
          delta_time.tv_usec = (long)(read_time * 1000);	// Convert remainder to MICROseconds

          // Store the current time
          timestamp = vrpn_TimevalSum(is900_zerotime, delta_time);
        } else {
	  vrpn_gettimeofday(&timestamp, NULL);	// Set watchdog now
	}

        //--------------------------------------------------------------------
        // If this sensor has an IS900 button on it, decode
        // the button values into the button device and mainloop the button
        // device so that it will report any changes.  Each button is stored
        // in one bit of the byte, with the lowest-numbered button in the
        // lowest bit.
        //--------------------------------------------------------------------

        if (is900_buttons[station]) {
	    for (i = 0; i < is900_buttons[station]->number_of_buttons(); i++) {
	      is900_buttons[station]->set_button(i, data.Station[station].ButtonState[i]);
	    }
            is900_buttons[station]->mainloop();
        }

        //--------------------------------------------------------------------
        // If this sensor has an IS900 analog on it, decode the analog values
        // into the analog device and mainloop the analog device so that it
        // will report any changes.  The first byte holds the unsigned char
        // representation of left/right.  The second holds up/down.  For each,
        // 0 means min (left or rear), 127 means center and 255 means max.
        //--------------------------------------------------------------------

        if (is900_analogs[station]) {
	  // Normalize the values to the range -1 to 1
	  is900_analogs[station]->setChannelValue(0, (data.Station[station].AnalogData[0] - 127) / 128.0);
	  is900_analogs[station]->setChannelValue(1, (data.Station[station].AnalogData[1] - 127) / 128.0);

	  // Report the new values
	  is900_analogs[station]->report_changes();
	  is900_analogs[station]->mainloop();
	}

	// Copy the tracker data into our internal storage before sending
	// (no unit problem as the Position vector is already in meters, see ISD_STATION_STATE_TYPE)
	// Watch: For some reason, to get consistent rotation and translation axis permutations,
	//        we need non direct mapping.
        // RMT: Based on a report from Christian Odom, it seems like the Quaternions in the
        //      Isense are QXYZ, whereas in Quatlib (and VRPN) they are XYZQ.  Once these
        //      are switched correctly, the positions can be read without strange swapping.
	pos[0] = data.Station[station].Position[0];
	pos[1] = data.Station[station].Position[1];
	pos[2] = data.Station[station].Position[2];

	if(m_StationInfo[station].AngleFormat == ISD_QUATERNION) {
		d_quat[0] = data.Station[station].Quaternion[1];
		d_quat[1] = data.Station[station].Quaternion[2];
		d_quat[2] = data.Station[station].Quaternion[3];
		d_quat[3] = data.Station[station].Quaternion[0];
        } else {
	        // Just return Euler for now...
	        // nahon@virtools needs to convert to radians
		angles[0] = DEG_TO_RAD*data.Station[station].Euler[0];
		angles[1] = DEG_TO_RAD*data.Station[station].Euler[1];
		angles[2] = DEG_TO_RAD*data.Station[station].Euler[2];

		q_from_euler(d_quat, angles[0], angles[1], angles[2]);
	}

	// have to just send it now
        status = vrpn_TRACKER_REPORT_READY;
//	fprintf(stderr, "sending message len %d\n", len);
	send_report();

	//printf("Isense %f, %f, %f\n",pos[0],pos[1],pos[2]);
	//printf("Isense a:%f, %f, %f : ",angles[0],angles[1],angles[2]); //if the tracker reports a quat, these will be garbage
	//printf("q: %f, %f, %f, %f\n",d_quat[0],d_quat[1],d_quat[2],d_quat[3]);
      }
    }

  }
#endif
}

void vrpn_Tracker_InterSense::send_report(void)
{
#ifdef  VRPN_INCLUDE_INTERSENSE
	// Send the message on the connection
    if (d_connection)
    {
	    char	msgbuf[1000];
	    int	len = encode_to(msgbuf);
	    if (d_connection->pack_message(len, timestamp, position_m_id, d_sender_id, msgbuf,
	    vrpn_CONNECTION_LOW_LATENCY)) {
	      fprintf(stderr,"InterSense: cannot write message: tossing\n");
	    }
	}
#endif
}

// This function should be called each time through the main loop
// of the server code. It polls for a report from the tracker and
// sends it if there is one. It will reset the tracker if there is
// no data from it for a few seconds.

void vrpn_Tracker_InterSense::mainloop()
{
  // Call the generic server mainloop, since we are a server
  server_mainloop();

  switch (status) {
    case vrpn_TRACKER_SYNCING:
    case vrpn_TRACKER_AWAITING_STATION:
    case vrpn_TRACKER_PARTIAL:
      {
	  // It turns out to be important to get the report before checking
	  // to see if it has been too long since the last report.  This is
	  // because there is the possibility that some other device running
	  // in the same server may have taken a long time on its last pass
	  // through mainloop().  Trackers that are resetting do this.  When
	  // this happens, you can get an infinite loop -- where one tracker
	  // resets and causes the other to timeout, and then it returns the
	  // favor.  By checking for the report here, we reset the timestamp
	  // if there is a report ready (ie, if THIS device is still operating).

	  get_report();

	  // Ready for another report
	  status = vrpn_TRACKER_SYNCING;
      }
      break;

    case vrpn_TRACKER_RESETTING:
      reset();
      break;

    case vrpn_TRACKER_FAIL:
      VRPN_MSG_WARNING("Tracking failed, trying to reset (try power cycle if more than 4 attempts made)");
      status = vrpn_TRACKER_RESETTING;
      break;
  }
}

/** This function indicates to the driver that there is some sort of InterSense IS-900-
    compatible button device attached to the port (either a Wand or a Stylus).  The driver
    will configure the device to send reports when buttons are pressed and released.

    This routine returns 0 on success and -1 on failure (due to the sensor number being too
    large or errors writing to the device or can't create the button).
*/

int vrpn_Tracker_InterSense::add_is900_button(const char *button_device_name, int sensor, int numbuttons)
{
    // Make sure this is a valid sensor
    if ( (sensor < 0) || (sensor >= ISD_MAX_STATIONS) ) {
    	return -1;
    }

    // Add a new button device and set the pointer to point at it.
    is900_buttons[sensor] = new vrpn_Button_Server(button_device_name, d_connection, numbuttons);
    if (is900_buttons[sensor] == NULL) {
    	VRPN_MSG_ERROR("Cannot open button device");
    	return -1;
    }

    // Send a new station-format command to the tracker so it will report the button states.
    return set_sensor_output_format(sensor);
}

/** This function indicates to the driver that there is an InterSense IS-900-
    compatible joystick device attached to the port (a Wand).  The driver
    will configure the device to send reports indicating the current status of the
    analogs when they change.  Note that a separate call to add_is900_button must
    be made in order to enable the buttons on the wand: this routine only handles
    the analog channels.

    The c0 and c1 parameters specify the clipping and scaling to take the reports
    from the two joystick axes into the range [-1..1].  The default is unscaled.

    This routine returns 0 on success and -1 on failure (due to the sensor number being too
    large or errors writing to the device or can't create the analog).
*/

int vrpn_Tracker_InterSense::add_is900_analog(const char *analog_device_name, int sensor,
	    double c0Min, double c0Low, double c0Hi, double c0Max,
	    double c1Min, double c1Low, double c1Hi, double c1Max)
{
    // Make sure this is a valid sensor
    if ( (sensor < 0) || (sensor >= ISD_MAX_STATIONS) ) {
    	return -1;
    }

    // Add a new analog device and set the pointer to point at it.
    is900_analogs[sensor] = new vrpn_Clipping_Analog_Server(analog_device_name, d_connection);
    if (is900_analogs[sensor] == NULL) {
	      VRPN_MSG_ERROR("Cannot open analog device");
	      return -1;
    }

    // Set the analog to have two channels, and set its channels to 0 to start with
    is900_analogs[sensor]->setNumChannels(2);
    is900_analogs[sensor]->setChannelValue(0, 0.0);
    is900_analogs[sensor]->setChannelValue(1, 0.0);

    // Set the scaling on the two channels.
    is900_analogs[sensor]->setClipValues(0, c0Min, c0Low, c0Hi, c0Max);
    is900_analogs[sensor]->setClipValues(1, c1Min, c1Low, c1Hi, c1Max);

    // Send a new station-format command to the tracker so it will report the analog status
    return set_sensor_output_format(sensor);
}
#endif


text:
<SageTVPlugin>
  <Name>htmlparser</Name>
  <Identifier>htmlparser</Identifier>
  <Description>SageTV Dependency JAR Plugin for htmlparser-1.6.jar - no need to download directly</Description>
  <Author>stuckless</Author>
  <CreationDate>2010-04-08</CreationDate>
  <ModificationDate>2010.04.10</ModificationDate>
  <Version>1.6</Version>
  <Desktop>false</Desktop>

  <PluginType>Library</PluginType>

  <Package>
    <PackageType>JAR</PackageType>
    <Location>https://github.com/OpenSageTV/sagetv-plugin-repo/releases/download/1/htmlparser-1.6.jar.zip</Location>
    <MD5>E0C23FA097F2F6E6D29FEF452BAC7AAB</MD5>
  </Package>
</SageTVPlugin>