text:
package routers

import (
	"fmt"

	"github.com/Unknwon/paginater"

	"github.com/gogits/gogs/models"
	"github.com/gogits/gogs/modules/base"
	"github.com/gogits/gogs/modules/context"
	"github.com/gogits/gogs/modules/log"
	"github.com/gogits/gogs/modules/setting"
	"github.com/gogits/gogs/routers/user"
)

const (
	HOME                  base.TplName = "home"
	EXPLORE_REPOS         base.TplName = "explore/repos"
	EXPLORE_ADV           base.TplName = "explore/advanced"
	EXPLORE_USERS         base.TplName = "explore/users"
	EXPLORE_ORGANIZATIONS base.TplName = "explore/organizations"
	EXPLORE_SUBJECTS      base.TplName = "explore/subjects"
	EXPLORE_SEMESTERS     base.TplName = "explore/semesters"
	EXPLORE_GROUPS        base.TplName = "explore/groups"
	EXPLORE_TAGS          base.TplName = "explore/tags"
	EXPLORE_PROFESSORS    base.TplName = "explore/professors"
)

func Home(ctx *context.Context) {
	if ctx.IsSigned {
		if !ctx.User.IsActive && setting.Service.RegisterEmailConfirm {
			ctx.Data["Title"] = ctx.Tr("auth.active_your_account")
			ctx.HTML(200, user.ACTIVATE)
		} else {
			user.Dashboard(ctx)
		}
		return
	}

	// Check auto-login.
	uname := ctx.GetCookie(setting.CookieUserName)
	if len(uname) != 0 {
		ctx.Redirect(setting.AppSubUrl + "/user/login")
		return
	}

	ctx.Data["PageIsHome"] = true
	ctx.HTML(200, HOME)
}

type RepoSearchOptions struct {
	Counter  func(bool) int64
	Ranger   func(int, int) ([]*models.Repository, error)
	Private  bool
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderRepoSearch(ctx *context.Context, opts *RepoSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		repos []*models.Repository
		count int64
		err   error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		repos, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter(opts.Private)
	} else {
		repos, count, err = models.SearchRepositoryByName(&models.SearchRepoOptions{
			Keyword:  keyword,
			OrderBy:  opts.OrderBy,
			Private:  opts.Private,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchRepositoryByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)

	for _, repo := range repos {
		if err = repo.GetOwner(); err != nil {
			log.Trace("%s", repo)
			ctx.Handle(500, "GetOwner", fmt.Errorf("%d: %v", repo.ID, err))
			return
		}
	}
	ctx.Data["Repos"] = repos

	ctx.HTML(200, opts.TplName)
}

func ExploreRepos(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreRepositories"] = true

	RenderRepoSearch(ctx, &RepoSearchOptions{
		Counter:  models.CountRepositories,
		Ranger:   models.GetRecentUpdatedRepositories,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "repository.updated_unix DESC",
		TplName:  EXPLORE_REPOS,
	})
}

func RenderAdvancedRepoSearch(ctx *context.Context, opts *RepoSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		repos []*models.Repository
		count int64
		err   error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0  && ctx.Query("professor") == "" && ctx.Query("subject") == "" && ctx.Query("group") == "" && ctx.Query("semester") == "" {
		repos, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter(opts.Private)
	} else {
		repos, count, err = models.AdvancedSearchRepositoryByName(&models.AdvancedSearchRepoOptions{
			Keyword:  keyword,
			Prof:     ctx.Query("professor"),
			Subj:     ctx.Query("subject"),
			Group:    ctx.Query("group"),
			Sem:      ctx.Query("semester"),
			OrderBy:  opts.OrderBy,
			Private:  opts.Private,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchRepositoryByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)

	for _, repo := range repos {
		if err = repo.GetOwner(); err != nil {
			log.Trace("%s", repo)
			ctx.Handle(500, "GetOwner", fmt.Errorf("%d: %v", repo.ID, err))
			return
		}
	}
	ctx.Data["Repos"] = repos

	ctx.HTML(200, opts.TplName)
}

func AdvancedSearch(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("advanced")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreAdvanced"] = true

	subjects, err := models.GetSubjects()
	if err != nil {
		ctx.Handle(500, "GetSubjects", err)
		return
	}
	ctx.Data["Subjects"] = subjects

	semesters, err := models.GetSemesters()
	if err != nil {
		ctx.Handle(500, "GetSemesters", err)
		return
	}
	ctx.Data["Semesters"] = semesters

	groups, err := models.GetGroups()
	if err != nil {
		ctx.Handle(500, "GetGroups", err)
		return
	}
	ctx.Data["Groups"] = groups

	professors, err := models.GetProfessors()
	if err != nil {
		ctx.Handle(500, "GetProfessors", err)
		return
	}
	ctx.Data["Professors"] = professors

	RenderAdvancedRepoSearch(ctx, &RepoSearchOptions{
		Counter:  models.CountRepositories,
		Ranger:   models.GetRecentUpdatedRepositories,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "repository.updated_unix DESC",
		TplName:  EXPLORE_ADV,
	})
}

type UserSearchOptions struct {
	Type     models.UserType
	Counter  func() int64
	Ranger   func(int, int) ([]*models.User, error)
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderUserSearch(ctx *context.Context, opts *UserSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 1 {
		page = 1
	}

	var (
		users []*models.User
		count int64
		err   error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		users, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter()
	} else {
		users, count, err = models.SearchUserByName(&models.SearchUserOptions{
			Keyword:  keyword,
			Type:     opts.Type,
			OrderBy:  opts.OrderBy,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchUserByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)
	ctx.Data["Users"] = users

	ctx.HTML(200, opts.TplName)
}

func ExploreUsers(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreUsers"] = true

	RenderUserSearch(ctx, &UserSearchOptions{
		Type:     models.USER_TYPE_INDIVIDUAL,
		Counter:  models.CountUsers,
		Ranger:   models.Users,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "updated_unix DESC",
		TplName:  EXPLORE_USERS,
	})
}

func ExploreProfessors(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreProfessors"] = true

	RenderUserSearch(ctx, &UserSearchOptions{
		Type:     models.USER_TYPE_PROFESSOR,
		Counter:  models.CountProfessors,
		Ranger:   models.Professors,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "updated_unix DESC",
		TplName:  EXPLORE_PROFESSORS,
	})
}

func ExploreOrganizations(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreOrganizations"] = true

	RenderUserSearch(ctx, &UserSearchOptions{
		Type:     models.USER_TYPE_ORGANIZATION,
		Counter:  models.CountOrganizations,
		Ranger:   models.Organizations,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "updated_unix DESC",
		TplName:  EXPLORE_ORGANIZATIONS,
	})
}

type SubjectsSearchOptions struct {
	Counter  func() int64
	Ranger   func(int, int) ([]*models.Subject, error)
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderSubjectsSearch(ctx *context.Context, opts *SubjectsSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		subjects []*models.Subject
		count    int64
		err      error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		subjects, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter()
	} else {
		subjects, count, err = models.SearchSubjectByName(&models.SearchSubjectOptions{
			Keyword:  keyword,
			OrderBy:  opts.OrderBy,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchSubjectByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)
	ctx.Data["Subjects"] = subjects

	ctx.HTML(200, opts.TplName)
}

func ExploreSubjects(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreSubjects"] = true

	RenderSubjectsSearch(ctx, &SubjectsSearchOptions{
		Counter:  models.CountSubjects,
		Ranger:   models.Subjects,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "name ASC",
		TplName:  EXPLORE_SUBJECTS,
	})
}

type SemestersSearchOptions struct {
	Counter  func() int64
	Ranger   func(int, int) ([]*models.Semester, error)
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderSemestersSearch(ctx *context.Context, opts *SemestersSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		semesters []*models.Semester
		count     int64
		err       error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		semesters, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter()
	} else {
		semesters, count, err = models.SearchSemesterByName(&models.SearchSemesterOptions{
			Keyword:  keyword,
			OrderBy:  opts.OrderBy,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchSemesterByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)
	ctx.Data["Semesters"] = semesters

	ctx.HTML(200, opts.TplName)
}

func ExploreSemesters(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreSemesters"] = true

	RenderSemestersSearch(ctx, &SemestersSearchOptions{
		Counter:  models.CountSemesters,
		Ranger:   models.Semesters,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "name ASC",
		TplName:  EXPLORE_SEMESTERS,
	})
}

type GrupsSearchOptions struct {
	Counter  func() int64
	Ranger   func(int, int) ([]*models.Group, error)
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderGroupsSearch(ctx *context.Context, opts *GrupsSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		groups []*models.Group
		count  int64
		err    error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		groups, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter()
	} else {
		groups, count, err = models.SearchGroupByName(&models.SearchGroupOptions{
			Keyword:  keyword,
			OrderBy:  opts.OrderBy,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchGroupByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)
	ctx.Data["Groups"] = groups

	ctx.HTML(200, opts.TplName)
}

func ExploreGroups(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreGroups"] = true

	RenderGroupsSearch(ctx, &GrupsSearchOptions{
		Counter:  models.CountGroups,
		Ranger:   models.Groups,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "name ASC",
		TplName:  EXPLORE_GROUPS,
	})
}

type TagsSearchOptions struct {
	Counter  func() int64
	Ranger   func(int, int) ([]*models.Tag, error)
	PageSize int
	OrderBy  string
	TplName  base.TplName
}

func RenderTagsSearch(ctx *context.Context, opts *TagsSearchOptions) {
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		tags  []*models.Tag
		count int64
		err   error
	)

	keyword := ctx.Query("q")
	if len(keyword) == 0 {
		tags, err = opts.Ranger(page, opts.PageSize)
		if err != nil {
			ctx.Handle(500, "opts.Ranger", err)
			return
		}
		count = opts.Counter()
	} else {
		tags, count, err = models.SearchTagByName(&models.SearchTagOptions{
			Keyword:  keyword,
			OrderBy:  opts.OrderBy,
			Page:     page,
			PageSize: opts.PageSize,
		})
		if err != nil {
			ctx.Handle(500, "SearchTagByName", err)
			return
		}
	}
	ctx.Data["Keyword"] = keyword
	ctx.Data["Total"] = count
	ctx.Data["Page"] = paginater.New(int(count), opts.PageSize, page, 5)
	ctx.Data["Tags"] = tags

	ctx.HTML(200, opts.TplName)
}

func ExploreTags(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("explore")
	ctx.Data["PageIsExplore"] = true
	ctx.Data["PageIsExploreTags"] = true

	RenderTagsSearch(ctx, &TagsSearchOptions{
		Counter:  models.CountTags,
		Ranger:   models.Tags,
		PageSize: setting.UI.ExplorePagingNum,
		OrderBy:  "etiqueta ASC",
		TplName:  EXPLORE_TAGS,
	})
}

func NotFound(ctx *context.Context) {
	ctx.Data["Title"] = "Page Not Found"
	ctx.Handle(404, "home.NotFound", nil)
}


text:
FROM alpine:latest
MAINTAINER Riccardo B. Desantis <riccardobenito.desantis@gmail.com>

# Setting the environment
ENV HOSTNAME clpplus.rickdesantis.docker.com
ENV USERHOME  /root
ENV USER root
ENV JAVA_HOME /usr/lib/jvm/java-1.8-openjdk
ENV PATH $USERHOME/dsdriver/bin:$JAVA_HOME/bin:$PATH
ENV DB_HOSTNAME host
ENV DB_USER user
ENV DB_PASSWORD password
ENV DB_PORT 50000
ENV DB_NAME BLUDB

WORKDIR $USERHOME
# Update the repos and install all the used packages
RUN apk update && apk add --no-cache \
    bash \
    mksh \
    libxml2 \
    unzip \
    openjdk8-jre-base

# Install the client
ADD ibm_data_server_driver_package_linuxx64_v10.5.tar.gz .
WORKDIR $USERHOME/dsdriver
RUN sed 's|/bin/ksh|/bin/mksh|' < installDSDriver > installDSDriver-new && \
    mv installDSDriver-new installDSDriver && \
    chmod +x installDSDriver && \
    ./installDSDriver
WORKDIR $USERHOME/dsdriver/bin
RUN mv clpplus clpplus-orig && \
    printf "%b\n" '#!'"`which env` sh\n\ncd $USERHOME/dsdriver/bin\nif [ \$# -eq 0 ]; then\nsh ../db2profile && exec clpplus-orig -nw \$DB_USER/\$DB_PASSWORD@\$DB_HOSTNAME:\$DB_PORT/\$DB_NAME\nelse\nsh ../db2profile && exec clpplus-orig -nw \"\$@\"\nfi" > clpplus && \
    chmod +x clpplus

#ENTRYPOINT [ "clpplus" ]
RUN touch /tmp/empty
CMD tail -f /tmp/empty

# Build: docker build -t clpplus1 ../clpplus
# Run:   docker run --name=clpplus1 -it clpplus1 <user>/<password>@<host>:<port | 50000>/<dbname | BLUDB>
# Bash:  docker exec -it clpplus1 bash
# Start: docker start clpplus1
# Stop:  docker stop clpplus1

redpajama_set_name: RedPajamaGithub


text:
package com.github.pfichtner.fsltree.functional;

import java.util.ArrayList;
import java.util.List;

public final class Iterables {

	private Iterables() {
		super();
	}

	public static <T> T find(Iterable<T> components, Predicate<T> p) {
		for (T component : components) {
			if (p.apply(component)) {
				return component;
			}
		}
		return null;
	}

	public static <T, S> Iterable<S> transform(Iterable<? extends T> iterable,
			Function<T, S> function) {
		List<S> result = new ArrayList<S>();
		for (T i : iterable) {
			result.add(function.apply(i));
		}
		return result;
	}

}


text:
//
//  MCSlidingTabs.h
//  MCSlidingTabs
//
//  Created by Maxime Chaillou on 16/11/2015.
//  Copyright © 2015 Maxime Chaillou. All rights reserved.
//

#import <UIKit/UIKit.h>

/*!
 * @typedef MCSlidingTabsPosition
 * @brief A list of tab bar position
 * @constant MCSlidingTabsPositionTop The tab bar is at the top of the screen.
 * @constant MCSlidingTabsPositionBottom The tab bar is sticked at the bottom of the screen.
 */
typedef enum {
    MCSlidingTabsPositionTop,
    MCSlidingTabsPositionBottom
} MCSlidingTabsPosition;

@interface MCSlidingTabs : UIViewController

// Color Properties
/*!
 * @brief The color of the text and the image when the tab is not selected.
 */
@property UIColor* foregroundColorNormal;
/*!
 * @brief The color of tab's background when it is not selected.
 */
@property UIColor* backgroundColorNormal;
/*!
 * @brief The color of the text and the image when the tab is selected.
 */
@property UIColor* foregroundColorSelected;
/*!
 * @brief The color of tab's background when it is selected.
 */
@property UIColor* backgroundColorSelected;
/*!
 * @brief The color of the text and the image when the tab is hightlighted (when you press the button).
 */
@property UIColor* foregroundColorHighlighted;
/*!
 * @brief The font used in the tab
 */
@property UIFont* tabFont;

// MCSlidingsTabs Properties
/*!
 * @brief The height of the tab bar. Default = 40.0f.
 */
@property CGFloat barHeight;
/*!
 * @brief The position of the tab bar. Default = MCSlidingTabsPositionBottom.
 */
@property MCSlidingTabsPosition tabBarPosition;
/*!
 * @brief Defines if the views are animated or not (if not, it looks like default UITabBar). Default = YES.
 */
@property BOOL isAnimatedViews;

// Methods
/*!
 * @discussion Add a tab with a title only.
 * @param tabTitle A NSString to be used as title of the tab.
 * @param vc The viewController linked to the tab.
 * @return void
 */
- (void)addTab:(NSString *)tabTitle forViewController:(UIViewController *)vc;

/*!
 * @discussion Add a tab with an image only.
 * @param tabImage A UIImage to be used as icon of the tab.
 * @param vc The viewController linked to the tab.
 * @return void
 */
- (void)addTabImage:(UIImage *)tabImage forViewController:(UIViewController *)vc;

/*!
 * @discussion Add a tab with a title and an image.
 * @param tabTitle A NSString to be used as title of the tab.
 * @param tabImage A UIImage to be used as icon of the tab.
 * @param vc The viewController linked to the tab.
 * @return void
 */
- (void)addTab:(NSString *)tabTitle andImage:(UIImage *)tabImage forViewController:(UIViewController *)vc;

@end


text:
package fsb.semantics.naivepso;

import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;

import fsb.explore.Action;
import fsb.explore.BadMemoryException;
import fsb.explore.SBState;
import fsb.explore.StateFactory;
import fsb.semantics.Semantics;
import fsb.tvl.ArithValue;
import fsb.tvl.DetArithValue;

import fsb.ast.Allocate;
import fsb.ast.AtomicDec;
import fsb.ast.Branch;
import fsb.ast.CAS;
import fsb.ast.EndAtomic;
import fsb.ast.Load;
import fsb.ast.Statement;
import fsb.ast.Store;
import fsb.ast.Assign;
import fsb.ast.Swap;
import fsb.ast.SymbolTable;

public class NaiveAbsSemantics extends Semantics {
	private StateFactory factory;

	public NaiveAbsSemantics()
	{
		this.factory = new NaiveAbsStateFactory();
	}

	protected List<Action> getFlushes(SBState s, int pid)
	{
		NaiveAbsState state = (NaiveAbsState) s;
		List<Action> succ = new LinkedList<Action>();
		//Iterate over all the shared variables
		for (int res : state.shared.keySet())
		{
			SharedResVal sharedval = state.shared.get(res);
			for(ArithValue flushedval : sharedval.buffer[pid].set)
			{
				//Non-Destructive
				NaiveAbsState newstate = (NaiveAbsState) factory.newState(s);
				SharedResVal newsharedval = newstate.shared.get(res);
				newsharedval.directSetValue(flushedval);
				succ.add(new Action(s, newstate, null, pid, "" + pid + " FLUSH-ND " + res +
						" = " + flushedval));

				//Destructive
				newstate = (NaiveAbsState) factory.newState(s);
				newsharedval = newstate.shared.get(res);
				newsharedval.directSetValue(flushedval);
				newsharedval.flushDestructive(pid, flushedval);
				succ.add(new Action(s, newstate, null, pid, "" + pid + " FLUSH-D " + res +
						" = " + flushedval));
			}
		}
		return succ;
	}

	protected List<Action> applyAssign(SBState state, Assign assign, int pid) {
		List<Action> succ = new LinkedList<Action>();
		NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);

		//ASSIGN is local, just moves things inside L(p)...
		ArithValue val = assign.getSrcVal(state, pid);
		int dst = assign.getDst();
		newstate.setLocal(pid, dst, val);
		newstate.advancePC(pid);

		succ.add(new Action(state, newstate, assign, pid, "" + pid +
				"." + assign.getLabel() + " " + assign.toString()));
		return succ;
	}

	protected List<Action> applyAllocate(SBState state, Allocate allocate, int pid) {
		List<Action> succ = new LinkedList<Action>();
		NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);

		int num = allocate.getNumVal(state, pid);
		int mem = newstate.allocate(num);
		int dst = allocate.getDst();
		newstate.setLocal(pid, dst, DetArithValue.getInstance(mem));
		newstate.advancePC(pid);

		succ.add(new Action(state, newstate, allocate, pid, "" + pid +
				"." + allocate.getLabel() + " " + allocate.toString()));
		return succ;
	}

	protected List<Action> applyStore(SBState state, Store store, int pid) {
		List<Action> succ = new LinkedList<Action>();
		ArithValue val = store.getSrcVal(state, pid);

		//for (ArithValue val : vals) {
			NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
			int dst = store.getDst(state, pid);

			//Decide whether we want to STORE-S or STORE-H.
			//The reason the real work is wrapped is because we need
			//to support lazy copying. So we never change things in the buffers
			//explicitly, but leave it to the buffer object's discretion.
			try
			{
				SharedResVal newshared = newstate.shared.get(dst);
				newshared.buffer[pid].set.clear();
				newstate.advancePC(pid);
				succ.add(new Action(state, newstate, store, pid, "" + pid +
						"." + store.getLabel() + " " + store.toString()));
			}
			catch (NullPointerException e)
			{
				throw new BadMemoryException(SymbolTable.getGlobalVariableName(dst));
			}
		//}

		return succ;
	}

	protected List<Action> applyDirectStore(SBState state, Store store, int pid) {
		List<Action> succ = new LinkedList<Action>();
		ArithValue val = store.getSrcVal(state, pid);

		//for (ArithValue val : vals) {
			NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
			int dst = store.getDst(state, pid);

			try
			{
				SharedResVal newshared = newstate.shared.get(dst);
				newshared.directSetValue(val);

				newstate.advancePC(pid);
				succ.add(new Action(state, newstate, store, pid, "" + pid +
						"." + store.getLabel() + " " + store.toString()));
			}
			catch (NullPointerException e)
			{
				throw new BadMemoryException(SymbolTable.getGlobalVariableName(dst));
			}
		//}

		return succ;
	}

	protected List<Action> applyLoad(SBState s, Load load, int pid) {
		NaiveAbsState state = (NaiveAbsState) s;
		List<Action> succ = new LinkedList<Action>();
		int src = load.getSrc(state, pid);
		int  dst = load.getDst();
		try
		{
			SharedResVal sharedval = state.shared.get(src);

			//Note that BOTH options here are possible, if
			//we have validity.TOP
			if (sharedval.isEmptySet(pid))
			{
				//LOAD-G
				ArithValue val = sharedval.getGlobalVal();
				NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
				newstate.setLocal(pid, dst, val);
				newstate.advancePC(pid);
				succ.add(new Action(state, newstate, load, pid, "" + pid +
						"." + load.getLabel() + " " + load.toString() + " //G"));
			}
			else
			{
				//LOAD-S
				for(ArithValue val : sharedval.buffer[pid].set)
				{
					//Non-Destructive
					NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
					newstate.setLocal(pid, dst, val);

					newstate.advancePC(pid);
					succ.add(new Action(state, newstate, load, pid, "" + pid +
							"." + load.getLabel() + " " + load.toString() + " //" + val));
				}
			}

		} catch (NullPointerException e)
		{
			throw new BadMemoryException(SymbolTable.getGlobalVariableName(src));
		}
		return succ;
	}

	protected List<Action> applyCAS(SBState s, CAS cas, int pid) {
		NaiveAbsState state = (NaiveAbsState) s;
		List<Action> succ = new LinkedList<Action>();

		int sharedStr = cas.getShared(state, pid);
		SharedResVal sharedval;
		try
		{
			sharedval = state.shared.get(sharedStr);
			ArithValue val = sharedval.getGlobalVal();
			if (val == cas.getOldVal(state, pid))
			{
				//CAS-T
				NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
				SharedResVal newsharedval = newstate.shared.get(sharedStr);
				newstate.advancePC(pid);
				newsharedval.directSetValue(cas.getNewVal(state, pid));
				newstate.setLocal(pid, cas.getRes(), DetArithValue.getInstance(1));
				succ.add(new Action(state, newstate, cas, pid, "" + pid +
						"." + cas.getLabel() + " " + cas.toString() + " //G"));
			}
			else
			{
				//CAS-F
				NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
				newstate.advancePC(pid);
				newstate.setLocal(pid, cas.getRes(), DetArithValue.getInstance(0));
				succ.add(new Action(state, newstate, cas, pid, "" + pid +
						"." + cas.getLabel() + " " + cas.toString() + " //G"));
			}
		}
		catch (NullPointerException e)
		{
			throw new BadMemoryException(SymbolTable.getGlobalVariableName(sharedStr));
		}

		return succ;
	}

	protected List<Action> applySwap(SBState s, Swap swap, int pid) {
		NaiveAbsState state = (NaiveAbsState) s;
		List<Action> succ = new LinkedList<Action>();
		int sharedStr = swap.getShared(state, pid);
		int local = swap.getRes();

		try
		{
			SharedResVal sharedval = state.shared.get(sharedStr);
			ArithValue val = sharedval.getGlobalVal();
			NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
			SharedResVal newsharedval = newstate.shared.get(sharedStr);
			newstate.advancePC(pid);

			newstate.setLocal(pid, local, val);
			newsharedval.directSetValue(swap.getNewVal(state, pid));

			succ.add(new Action(state, newstate, swap, pid, "" + pid +
					"." + swap.getLabel() + " " + swap.toString() + " //G"));

		}
		catch (NullPointerException e)
		{
			throw new BadMemoryException(SymbolTable.getGlobalVariableName(sharedStr));
		}
		return succ;
	}

	protected List<Action> applyAtomicDec(SBState s, AtomicDec dec, int pid) {
		NaiveAbsState state = (NaiveAbsState) s;
		List<Action> succ = new LinkedList<Action>();
		int sharedStr = dec.getShared(state, pid);
		int local = dec.getRes();

		try
		{
			SharedResVal sharedval = state.shared.get(sharedStr);
			ArithValue val = sharedval.getGlobalVal();

			NaiveAbsState newstate = (NaiveAbsState) factory.newState(state);
			SharedResVal newsharedval = newstate.shared.get(sharedStr);
			newstate.advancePC(pid);

			newstate.setLocal(pid, local, val);
			newsharedval.directSetValue(val.minus(DetArithValue.getInstance(1)));

			succ.add(new Action(state, newstate, dec, pid, "" + pid +
					"." + dec.getLabel() + " " + dec.toString() + " //G"));

		}
		catch (NullPointerException e)
		{
			throw new BadMemoryException(SymbolTable.getGlobalVariableName(sharedStr));
		}
		return succ;
	}

	protected List<Action> applyBarrier(SBState origState, Statement statement, int pid) {
		List<Action> succ = new LinkedList<Action>();

		NaiveAbsState newState = (NaiveAbsState) factory.newState(origState);
		if(!statement.isLast())
			newState.advancePC(pid);

		succ.add(new Action(origState, newState, statement, pid, "" + pid +
			"." + statement.getLabel() + " " + statement.toString()));
		return succ;
	}

	protected List<Action> applyEndAtomic(SBState state, EndAtomic statement, int pid)
	{
		throw new RuntimeException("Not supported under Naive Set Abstraction");
		//TODO: This requires computing the Cartesian product of possible values for all variables.
		//Later!
	}

	@Override
	public StateFactory getStateFactory() {
		return factory;
	}

	public boolean isEnabled(SBState s, int pid, Statement statement) {
		NaiveAbsState state = (NaiveAbsState) s;
		int sharedStr = SymbolTable.getOrCreateGlobalVariable("BAD!");
		try
		{
			switch (statement.getType())
			{
			case CAS:
				{
					CAS cas = (CAS) statement;
					sharedStr = cas.getShared(state, pid);
					SharedResVal sharedval;
					sharedval = state.shared.get(sharedStr);
					return (sharedval.isEmptySet(pid));
				}
			case SWAP:
				{
					Swap swap = (Swap) statement;
					sharedStr = swap.getShared(state, pid);
					SharedResVal sharedval;
					sharedval = state.shared.get(sharedStr);
					return (sharedval.isEmptySet(pid));
				}
			case ATOMICDEC:
				{
					AtomicDec dec = (AtomicDec) statement;
					sharedStr = dec.getShared(state, pid);
					SharedResVal sharedval;
					sharedval = state.shared.get(sharedStr);
					return (sharedval.isEmptySet(pid));
				}
			case BARRIER:
				{
					for (Entry<Integer, SharedResVal> entry : state.shared.entrySet())
					{
						SharedResVal sharedval = entry.getValue();
						if (!sharedval.isEmptySet(pid))
							return false;
					}
					return true;
				}
			default:
				return true;
			}
		}
		catch (NullPointerException e)
		{
			throw new BadMemoryException(SymbolTable.getGlobalVariableName(sharedStr));
		}

	}
}


text:
matchismo
=========

Assignment 1: Matchismo (CS193 Fall 2013)


text:
static tBoolean
TimerBaseValid(unsigned long ulBase)
{
    return((ulBase == TIMER0_BASE) || (ulBase == TIMER1_BASE) ||
           (ulBase == TIMER2_BASE) || (ulBase == TIMER3_BASE));
}
#endif

//*****************************************************************************
//
//! Enables the timer(s).
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to enable; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//!
//! This will enable operation of the timer module.  The timer must be
//! configured before it is enabled.
//!
//! \return None.
//
//*****************************************************************************
void
TimerEnable(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Enable the timer(s) module.
    //
    HWREG(ulBase + TIMER_O_CTL) |= ulTimer & (TIMER_CTL_TAEN | TIMER_CTL_TBEN);
}

//*****************************************************************************
//
//! Disables the timer(s).
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to disable; must be one of
//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH.
//!
//! This will disable operation of the timer module.
//!
//! \return None.
//
//*****************************************************************************
void
TimerDisable(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Disable the timer module.
    //
    HWREG(ulBase + TIMER_O_CTL) &= ~(ulTimer &
                                     (TIMER_CTL_TAEN | TIMER_CTL_TBEN));
}

//*****************************************************************************
//
//! Configures the timer(s).
//!
//! \param ulBase is the base address of the timer module.
//! \param ulConfig is the configuration for the timer.
//!
//! This function configures the operating mode of the timer(s).  The timer
//! module is disabled before being configured, and is left in the disabled
//! state.  The configuration is specified in \e ulConfig as one of the
//! following values:
//!
//! - \b TIMER_CFG_32_BIT_OS - 32-bit one-shot timer
//! - \b TIMER_CFG_32_BIT_OS_UP - 32-bit one-shot timer that counts up instead
//!   of down (not available on all parts)
//! - \b TIMER_CFG_32_BIT_PER - 32-bit periodic timer
//! - \b TIMER_CFG_32_BIT_PER_UP - 32-bit periodic timer that counts up instead
//!   of down (not available on all parts)
//! - \b TIMER_CFG_32_RTC - 32-bit real time clock timer
//! - \b TIMER_CFG_16_BIT_PAIR - Two 16-bit timers
//!
//! When configured for a pair of 16-bit timers, each timer is separately
//! configured.  The first timer is configured by setting \e ulConfig to
//! the result of a logical OR operation between one of the following values
//! and \e ulConfig:
//!
//! - \b TIMER_CFG_A_ONE_SHOT - 16-bit one-shot timer
//! - \b TIMER_CFG_A_ONE_SHOT_UP - 16-bit one-shot timer that counts up instead
//!   of down (not available on all parts)
//! - \b TIMER_CFG_A_PERIODIC - 16-bit periodic timer
//! - \b TIMER_CFG_A_PERIODIC_UP - 16-bit periodic timer that counts up instead
//!   of down (not available on all parts)
//! - \b TIMER_CFG_A_CAP_COUNT - 16-bit edge count capture
//! - \b TIMER_CFG_A_CAP_TIME - 16-bit edge time capture
//! - \b TIMER_CFG_A_PWM - 16-bit PWM output
//!
//! Similarly, the second timer is configured by setting \e ulConfig to
//! the result of a logical OR operation between one of the corresponding
//! \b TIMER_CFG_B_* values and \e ulConfig.
//!
//! \return None.
//
//*****************************************************************************
void
TimerConfigure(unsigned long ulBase, unsigned long ulConfig)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulConfig == TIMER_CFG_32_BIT_OS) ||
           (ulConfig == TIMER_CFG_32_BIT_OS_UP) ||
           (ulConfig == TIMER_CFG_32_BIT_PER) ||
           (ulConfig == TIMER_CFG_32_BIT_PER_UP) ||
           (ulConfig == TIMER_CFG_32_RTC) ||
           ((ulConfig & 0xff000000) == TIMER_CFG_16_BIT_PAIR));
    ASSERT(((ulConfig & 0xff000000) != TIMER_CFG_16_BIT_PAIR) ||
           ((((ulConfig & 0x000000ff) == TIMER_CFG_A_ONE_SHOT) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_ONE_SHOT_UP) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_PERIODIC) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_PERIODIC_UP) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_CAP_COUNT) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_CAP_TIME) ||
             ((ulConfig & 0x000000ff) == TIMER_CFG_A_PWM)) &&
            (((ulConfig & 0x0000ff00) == TIMER_CFG_B_ONE_SHOT) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_ONE_SHOT_UP) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PERIODIC) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PERIODIC_UP) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_CAP_COUNT) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_CAP_TIME) ||
             ((ulConfig & 0x0000ff00) == TIMER_CFG_B_PWM))));

    //
    // Disable the timers.
    //
    HWREG(ulBase + TIMER_O_CTL) &= ~(TIMER_CTL_TAEN | TIMER_CTL_TBEN);

    //
    // Set the global timer configuration.
    //
    HWREG(ulBase + TIMER_O_CFG) = ulConfig >> 24;

    //
    // Set the configuration of the A and B timers.  Note that the B timer
    // configuration is ignored by the hardware in 32-bit modes.
    //
    HWREG(ulBase + TIMER_O_TAMR) = ulConfig & 255;
    HWREG(ulBase + TIMER_O_TBMR) = (ulConfig >> 8) & 255;
}

//*****************************************************************************
//
//! Controls the output level.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//! \param bInvert specifies the output level.
//!
//! This function sets the PWM output level for the specified timer.  If the
//! \e bInvert parameter is \b true, then the timer's output will be made
//! active low; otherwise, it will be made active high.
//!
//! \return None.
//
//*****************************************************************************
void
TimerControlLevel(unsigned long ulBase, unsigned long ulTimer,
                  tBoolean bInvert)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the output levels as requested.
    //
    ulTimer &= TIMER_CTL_TAPWML | TIMER_CTL_TBPWML;
    HWREG(ulBase + TIMER_O_CTL) = (bInvert ?
                                   (HWREG(ulBase + TIMER_O_CTL) | ulTimer) :
                                   (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer)));
}

//*****************************************************************************
//
//! Enables or disables the trigger output.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//! \param bEnable specifies the desired trigger state.
//!
//! This function controls the trigger output for the specified timer.  If the
//! \e bEnable parameter is \b true, then the timer's output trigger is
//! enabled; otherwise it is disabled.
//!
//! \return None.
//
//*****************************************************************************
void
TimerControlTrigger(unsigned long ulBase, unsigned long ulTimer,
                    tBoolean bEnable)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the trigger output as requested.
    //
    ulTimer &= TIMER_CTL_TAOTE | TIMER_CTL_TBOTE;
    HWREG(ulBase + TIMER_O_CTL) = (bEnable ?
                                   (HWREG(ulBase + TIMER_O_CTL) | ulTimer) :
                                   (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer)));
}

//*****************************************************************************
//
//! Controls the event type.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to be adjusted; must be one of
//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH.
//! \param ulEvent specifies the type of event; must be one of
//! \b TIMER_EVENT_POS_EDGE, \b TIMER_EVENT_NEG_EDGE, or
//! \b TIMER_EVENT_BOTH_EDGES.
//!
//! This function sets the signal edge(s) that will trigger the timer when in
//! capture mode.
//!
//! \return None.
//
//*****************************************************************************
void
TimerControlEvent(unsigned long ulBase, unsigned long ulTimer,
                  unsigned long ulEvent)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the event type.
    //
    ulEvent &= ulTimer & (TIMER_CTL_TAEVENT_M | TIMER_CTL_TBEVENT_M);
    HWREG(ulBase + TIMER_O_CTL) = ((HWREG(ulBase + TIMER_O_CTL) &
                                    ~(TIMER_CTL_TAEVENT_M |
                                      TIMER_CTL_TBEVENT_M)) | ulEvent);
}

//*****************************************************************************
//
//! Controls the stall handling.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to be adjusted; must be one of
//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH.
//! \param bStall specifies the response to a stall signal.
//!
//! This function controls the stall response for the specified timer.  If the
//! \e bStall parameter is \b true, then the timer will stop counting if the
//! processor enters debug mode; otherwise the timer will keep running while in
//! debug mode.
//!
//! \return None.
//
//*****************************************************************************
void
TimerControlStall(unsigned long ulBase, unsigned long ulTimer,
                  tBoolean  bStall)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the stall mode.
    //
    ulTimer &= TIMER_CTL_TASTALL | TIMER_CTL_TBSTALL;
    HWREG(ulBase + TIMER_O_CTL) = (bStall ?
                                   (HWREG(ulBase + TIMER_O_CTL) | ulTimer) :
                                   (HWREG(ulBase + TIMER_O_CTL) & ~(ulTimer)));
}

//*****************************************************************************
//
//! Controls the wait on trigger handling.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to be adjusted; must be one of
//! \b TIMER_A, \b TIMER_B, or \b TIMER_BOTH.
//! \param bWait specifies if the timer should wait for a trigger input.
//!
//! This function controls whether or not a timer waits for a trigger input to
//! start counting.  When enabled, the previous timer in the trigger chain must
//! count to its timeout in order for this timer to start counting.  Refer to
//! the part's data sheet for a description of the trigger chain.
//!
//! \note This functionality is not available on all parts.
//!
//! \return None.
//
//*****************************************************************************
void
TimerControlWaitOnTrigger(unsigned long ulBase, unsigned long ulTimer,
                          tBoolean bWait)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the wait on trigger mode for timer A.
    //
    if((ulTimer & TIMER_A) != 0)
    {
        if(bWait)
        {
            HWREG(ulBase + TIMER_O_TAMR) |= TIMER_TAMR_TAWOT;
        }
        else
        {
            HWREG(ulBase + TIMER_O_TAMR) &= ~(TIMER_TAMR_TAWOT);
        }
    }

    //
    // Set the wait on trigger mode for timer A.
    //
    if((ulTimer & TIMER_B) != 0)
    {
        if(bWait)
        {
            HWREG(ulBase + TIMER_O_TBMR) |= TIMER_TBMR_TBWOT;
        }
        else
        {
            HWREG(ulBase + TIMER_O_TBMR) &= ~(TIMER_TBMR_TBWOT);
        }
    }
}

//*****************************************************************************
//
//! Enable RTC counting.
//!
//! \param ulBase is the base address of the timer module.
//!
//! This function causes the timer to start counting when in RTC mode.  If not
//! configured for RTC mode, this will do nothing.
//!
//! \return None.
//
//*****************************************************************************
void
TimerRTCEnable(unsigned long ulBase)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Enable RTC counting.
    //
    HWREG(ulBase + TIMER_O_CTL) |= TIMER_CTL_RTCEN;
}

//*****************************************************************************
//
//! Disable RTC counting.
//!
//! \param ulBase is the base address of the timer module.
//!
//! This function causes the timer to stop counting when in RTC mode.
//!
//! \return None.
//
//*****************************************************************************
void
TimerRTCDisable(unsigned long ulBase)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Disable RTC counting.
    //
    HWREG(ulBase + TIMER_O_CTL) &= ~(TIMER_CTL_RTCEN);
}

//*****************************************************************************
//
//! Set the timer prescale value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//! \param ulValue is the timer prescale value; must be between 0 and 255,
//! inclusive.
//!
//! This function sets the value of the input clock prescaler.  The prescaler
//! is only operational when in 16-bit mode and is used to extend the range of
//! the 16-bit timer modes.
//!
//! \return None.
//
//*****************************************************************************
void
TimerPrescaleSet(unsigned long ulBase, unsigned long ulTimer,
                 unsigned long ulValue)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));
    ASSERT(ulValue < 256);

    //
    // Set the timer A prescaler if requested.
    //
    if(ulTimer & TIMER_A)
    {
        HWREG(ulBase + TIMER_O_TAPR) = ulValue;
    }

    //
    // Set the timer B prescaler if requested.
    //
    if(ulTimer & TIMER_B)
    {
        HWREG(ulBase + TIMER_O_TBPR) = ulValue;
    }
}

//*****************************************************************************
//
//! Get the timer prescale value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer; must be one of \b TIMER_A or
//! \b TIMER_B.
//!
//! This function gets the value of the input clock prescaler.  The prescaler
//! is only operational when in 16-bit mode and is used to extend the range of
//! the 16-bit timer modes.
//!
//! \return The value of the timer prescaler.
//
//*****************************************************************************
unsigned long
TimerPrescaleGet(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Return the appropriate prescale value.
    //
    return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAPR) :
           HWREG(ulBase + TIMER_O_TBPR));
}

//*****************************************************************************
//
//! Set the timer prescale match value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//! \param ulValue is the timer prescale match value; must be between 0 and
//! 255, inclusive.
//!
//! This function sets the value of the input clock prescaler match value.
//! When in a 16-bit mode that uses the counter match and the prescaler, the
//! prescale match effectively extends the range of the counter to 24-bits.
//!
//! \note This functionality is not available on all parts.
//!
//! \return None.
//
//*****************************************************************************
void
TimerPrescaleMatchSet(unsigned long ulBase, unsigned long ulTimer,
                      unsigned long ulValue)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));
    ASSERT(ulValue < 256);

    //
    // Set the timer A prescale match if requested.
    //
    if(ulTimer & TIMER_A)
    {
        HWREG(ulBase + TIMER_O_TAPMR) = ulValue;
    }

    //
    // Set the timer B prescale match if requested.
    //
    if(ulTimer & TIMER_B)
    {
        HWREG(ulBase + TIMER_O_TBPMR) = ulValue;
    }
}

//*****************************************************************************
//
//! Get the timer prescale match value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer; must be one of \b TIMER_A or
//! \b TIMER_B.
//!
//! This function gets the value of the input clock prescaler match value.
//! When in a 16-bit mode that uses the counter match and prescaler, the
//! prescale match effectively extends the range of the counter to 24-bits.
//!
//! \note This functionality is not available on all parts.
//!
//! \return The value of the timer prescale match.
//
//*****************************************************************************
unsigned long
TimerPrescaleMatchGet(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Return the appropriate prescale match value.
    //
    return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAPMR) :
           HWREG(ulBase + TIMER_O_TBPMR));
}

//*****************************************************************************
//
//! Sets the timer load value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.  Only \b TIMER_A should be used when the
//! timer is configured for 32-bit operation.
//! \param ulValue is the load value.
//!
//! This function sets the timer load value; if the timer is running then the
//! value will be immediately loaded into the timer.
//!
//! \return None.
//
//*****************************************************************************
void
TimerLoadSet(unsigned long ulBase, unsigned long ulTimer,
             unsigned long ulValue)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the timer A load value if requested.
    //
    if(ulTimer & TIMER_A)
    {
        HWREG(ulBase + TIMER_O_TAILR) = ulValue;
    }

    //
    // Set the timer B load value if requested.
    //
    if(ulTimer & TIMER_B)
    {
        HWREG(ulBase + TIMER_O_TBILR) = ulValue;
    }
}

//*****************************************************************************
//
//! Gets the timer load value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer; must be one of \b TIMER_A or
//! \b TIMER_B.  Only \b TIMER_A should be used when the timer is configured
//! for 32-bit operation.
//!
//! This function gets the currently programmed interval load value for the
//! specified timer.
//!
//! \return Returns the load value for the timer.
//
//*****************************************************************************
unsigned long
TimerLoadGet(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B));

    //
    // Return the appropriate load value.
    //
    return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAILR) :
           HWREG(ulBase + TIMER_O_TBILR));
}

//*****************************************************************************
//
//! Gets the current timer value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer; must be one of \b TIMER_A or
//! \b TIMER_B.  Only \b TIMER_A should be used when the timer is configured
//! for 32-bit operation.
//!
//! This function reads the current value of the specified timer.
//!
//! \return Returns the current value of the timer.
//
//*****************************************************************************
unsigned long
TimerValueGet(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B));

    //
    // Return the appropriate timer value.
    //
    return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAR) :
           HWREG(ulBase + TIMER_O_TBR));
}

//*****************************************************************************
//
//! Sets the timer match value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s) to adjust; must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.  Only \b TIMER_A should be used when the
//! timer is configured for 32-bit operation.
//! \param ulValue is the match value.
//!
//! This function sets the match value for a timer.  This is used in capture
//! count mode to determine when to interrupt the processor and in PWM mode to
//! determine the duty cycle of the output signal.
//!
//! \return None.
//
//*****************************************************************************
void
TimerMatchSet(unsigned long ulBase, unsigned long ulTimer,
              unsigned long ulValue)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Set the timer A match value if requested.
    //
    if(ulTimer & TIMER_A)
    {
        HWREG(ulBase + TIMER_O_TAMATCHR) = ulValue;
    }

    //
    // Set the timer B match value if requested.
    //
    if(ulTimer & TIMER_B)
    {
        HWREG(ulBase + TIMER_O_TBMATCHR) = ulValue;
    }
}

//*****************************************************************************
//
//! Gets the timer match value.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer; must be one of \b TIMER_A or
//! \b TIMER_B.  Only \b TIMER_A should be used when the timer is configured
//! for 32-bit operation.
//!
//! This function gets the match value for the specified timer.
//!
//! \return Returns the match value for the timer.
//
//*****************************************************************************
unsigned long
TimerMatchGet(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B));

    //
    // Return the appropriate match value.
    //
    return((ulTimer == TIMER_A) ? HWREG(ulBase + TIMER_O_TAMATCHR) :
           HWREG(ulBase + TIMER_O_TBMATCHR));
}

//*****************************************************************************
//
//! Registers an interrupt handler for the timer interrupt.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s); must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//! \param pfnHandler is a pointer to the function to be called when the timer
//! interrupt occurs.
//!
//! This sets the handler to be called when a timer interrupt occurs.  This
//! will enable the global interrupt in the interrupt controller; specific
//! timer interrupts must be enabled via TimerIntEnable().  It is the interrupt
//! handler's responsibility to clear the interrupt source via TimerIntClear().
//!
//! \sa IntRegister() for important information about registering interrupt
//! handlers.
//!
//! \return None.
//
//*****************************************************************************
void
TimerIntRegister(unsigned long ulBase, unsigned long ulTimer,
                 void (*pfnHandler)(void))
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Get the interrupt number for this timer module.
    //
    ulBase = ((ulBase == TIMER0_BASE) ? INT_TIMER0A :
              ((ulBase == TIMER1_BASE) ? INT_TIMER1A :
               ((ulBase == TIMER2_BASE) ? INT_TIMER2A : INT_TIMER3A)));

    //
    // Register an interrupt handler for timer A if requested.
    //
    if(ulTimer & TIMER_A)
    {
        //
        // Register the interrupt handler.
        //
        IntRegister(ulBase, pfnHandler);

        //
        // Enable the interrupt.
        //
        IntEnable(ulBase);
    }

    //
    // Register an interrupt handler for timer B if requested.
    //
    if(ulTimer & TIMER_B)
    {
        //
        // Register the interrupt handler.
        //
        IntRegister(ulBase + 1, pfnHandler);

        //
        // Enable the interrupt.
        //
        IntEnable(ulBase + 1);
    }
}

//*****************************************************************************
//
//! Unregisters an interrupt handler for the timer interrupt.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulTimer specifies the timer(s); must be one of \b TIMER_A,
//! \b TIMER_B, or \b TIMER_BOTH.
//!
//! This function will clear the handler to be called when a timer interrupt
//! occurs.  This will also mask off the interrupt in the interrupt controller
//! so that the interrupt handler no longer is called.
//!
//! \sa IntRegister() for important information about registering interrupt
//! handlers.
//!
//! \return None.
//
//*****************************************************************************
void
TimerIntUnregister(unsigned long ulBase, unsigned long ulTimer)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));
    ASSERT((ulTimer == TIMER_A) || (ulTimer == TIMER_B) ||
           (ulTimer == TIMER_BOTH));

    //
    // Get the interrupt number for this timer module.
    //
    ulBase = ((ulBase == TIMER0_BASE) ? INT_TIMER0A :
              ((ulBase == TIMER1_BASE) ? INT_TIMER1A :
               ((ulBase == TIMER2_BASE) ? INT_TIMER2A : INT_TIMER3A)));

    //
    // Unregister the interrupt handler for timer A if requested.
    //
    if(ulTimer & TIMER_A)
    {
        //
        // Disable the interrupt.
        //
        IntDisable(ulBase);

        //
        // Unregister the interrupt handler.
        //
        IntUnregister(ulBase);
    }

    //
    // Unregister the interrupt handler for timer B if requested.
    //
    if(ulTimer & TIMER_B)
    {
        //
        // Disable the interrupt.
        //
        IntDisable(ulBase + 1);

        //
        // Unregister the interrupt handler.
        //
        IntUnregister(ulBase + 1);
    }
}

//*****************************************************************************
//
//! Enables individual timer interrupt sources.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulIntFlags is the bit mask of the interrupt sources to be enabled.
//!
//! Enables the indicated timer interrupt sources.  Only the sources that are
//! enabled can be reflected to the processor interrupt; disabled sources have
//! no effect on the processor.
//!
//! The \e ulIntFlags parameter must be the logical OR of any combination of
//! the following:
//!
//! - \b TIMER_CAPB_EVENT  - Capture B event interrupt
//! - \b TIMER_CAPB_MATCH  - Capture B match interrupt
//! - \b TIMER_TIMB_TIMEOUT  - Timer B timeout interrupt
//! - \b TIMER_RTC_MATCH  - RTC interrupt mask
//! - \b TIMER_CAPA_EVENT  - Capture A event interrupt
//! - \b TIMER_CAPA_MATCH  - Capture A match interrupt
//! - \b TIMER_TIMA_TIMEOUT  - Timer A timeout interrupt
//!
//! \return None.
//
//*****************************************************************************
void
TimerIntEnable(unsigned long ulBase, unsigned long ulIntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Enable the specified interrupts.
    //
    HWREG(ulBase + TIMER_O_IMR) |= ulIntFlags;
}

//*****************************************************************************
//
//! Disables individual timer interrupt sources.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulIntFlags is the bit mask of the interrupt sources to be disabled.
//!
//! Disables the indicated timer interrupt sources.  Only the sources that are
//! enabled can be reflected to the processor interrupt; disabled sources have
//! no effect on the processor.
//!
//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags
//! parameter to TimerIntEnable().
//!
//! \return None.
//
//*****************************************************************************
void
TimerIntDisable(unsigned long ulBase, unsigned long ulIntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Disable the specified interrupts.
    //
    HWREG(ulBase + TIMER_O_IMR) &= ~(ulIntFlags);
}

//*****************************************************************************
//
//! Gets the current interrupt status.
//!
//! \param ulBase is the base address of the timer module.
//! \param bMasked is false if the raw interrupt status is required and true if
//! the masked interrupt status is required.
//!
//! This returns the interrupt status for the timer module.  Either the raw
//! interrupt status or the status of interrupts that are allowed to reflect to
//! the processor can be returned.
//!
//! \return The current interrupt status, enumerated as a bit field of
//! values described in TimerIntEnable().
//
//*****************************************************************************
unsigned long
TimerIntStatus(unsigned long ulBase, tBoolean bMasked)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Return either the interrupt status or the raw interrupt status as
    // requested.
    //
    return(bMasked ? HWREG(ulBase + TIMER_O_MIS) :
           HWREG(ulBase + TIMER_O_RIS));
}

//*****************************************************************************
//
//! Clears timer interrupt sources.
//!
//! \param ulBase is the base address of the timer module.
//! \param ulIntFlags is a bit mask of the interrupt sources to be cleared.
//!
//! The specified timer interrupt sources are cleared, so that they no longer
//! assert.  This must be done in the interrupt handler to keep it from being
//! called again immediately upon exit.
//!
//! The \e ulIntFlags parameter has the same definition as the \e ulIntFlags
//! parameter to TimerIntEnable().
//!
//! \note Since there is a write buffer in the Cortex-M3 processor, it may take
//! several clock cycles before the interrupt source is actually cleared.
//! Therefore, it is recommended that the interrupt source be cleared early in
//! the interrupt handler (as opposed to the very last action) to avoid
//! returning from the interrupt handler before the interrupt source is
//! actually cleared.  Failure to do so may result in the interrupt handler
//! being immediately reentered (since NVIC still sees the interrupt source
//! asserted).
//!
//! \return None.
//
//*****************************************************************************
void
TimerIntClear(unsigned long ulBase, unsigned long ulIntFlags)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Clear the requested interrupt sources.
    //
    HWREG(ulBase + TIMER_O_ICR) = ulIntFlags;
}

//*****************************************************************************
//
// Puts the timer into its reset state.
//
// \param ulBase is the base address of the timer module.
//
// The specified timer is disabled, and all its interrupts are disabled,
// cleared, and unregistered.  Then the timer registers are set to their reset
// value.
//
// \return None.
//
//*****************************************************************************
#ifndef DEPRECATED
void
TimerQuiesce(unsigned long ulBase)
{
    //
    // Check the arguments.
    //
    ASSERT(TimerBaseValid(ulBase));

    //
    // Disable the timer.
    //
    HWREG(ulBase + TIMER_O_CTL) = TIMER_RV_CTL;

    //
    // Disable all the timer interrupts.
    //
    HWREG(ulBase + TIMER_O_IMR) = TIMER_RV_IMR;

    //
    // Clear all the timer interrupts.
    //
    HWREG(ulBase + TIMER_O_ICR) = 0xFFFFFFFF;

    //
    // Unregister the interrupt handler.  This also disables interrupts to the
    // core.
    //
    TimerIntUnregister(ulBase, TIMER_BOTH);

    //
    // Set all the registers to their reset value.
    //
    HWREG(ulBase + TIMER_O_CFG) = TIMER_RV_CFG;
    HWREG(ulBase + TIMER_O_TAMR) = TIMER_RV_TAMR;
    HWREG(ulBase + TIMER_O_TBMR) = TIMER_RV_TBMR;
    HWREG(ulBase + TIMER_O_RIS) = TIMER_RV_RIS;
    HWREG(ulBase + TIMER_O_MIS) = TIMER_RV_MIS;
    HWREG(ulBase + TIMER_O_TAILR) = TIMER_RV_TAILR;
    HWREG(ulBase + TIMER_O_TBILR) = TIMER_RV_TBILR;
    HWREG(ulBase + TIMER_O_TAMATCHR) = TIMER_RV_TAMATCHR;
    HWREG(ulBase + TIMER_O_TBMATCHR) = TIMER_RV_TBMATCHR;
    HWREG(ulBase + TIMER_O_TAPR) = TIMER_RV_TAPR;
    HWREG(ulBase + TIMER_O_TBPR) = TIMER_RV_TBPR;
    HWREG(ulBase + TIMER_O_TAPMR) = TIMER_RV_TAPMR;
    HWREG(ulBase + TIMER_O_TBPMR) = TIMER_RV_TBPMR;
    HWREG(ulBase + TIMER_O_TAR) = TIMER_RV_TAR;
    HWREG(ulBase + TIMER_O_TBR) = TIMER_RV_TBR;
}
#endif // DEPRECATED

//*****************************************************************************
//
// Close the Doxygen group.
//! @}
//
//*****************************************************************************


text:
<?php

use PhpFormatter\Token;

require_once __DIR__ . '/../bootstrap.php';

$token = new Token('string', T_STRING);

Assert::true($token->isType(T_STRING));
Assert::true($token->isType('T_STRING'));

Assert::true($token->isInTypes([T_STRING, T_WHILE]));
Assert::false($token->isInTypes([T_WHILE]));
Assert::false($token->isInTypes([]));

Assert::same($token->getType(), 'T_STRING');

Assert::false($token->isSingleValue('string'));

$token = new Token('string');

Assert::true($token->isType(NULL));

Assert::same($token->getType(), NULL);
Assert::false($token->isInTypes([]));

Assert::true($token->isSingleValue('string'));

Assert::true($token->isInSingleValues(['string', 'test']));

$token = Token::createFromZendToken(array(T_STRING, 'string', 1));

Assert::true($token->isType(T_STRING));

Assert::same($token->getValue(), 'string');

$token = Token::createFromZendToken('.');

Assert::true($token->isSingleValue('.'));

$token = new Token('string', T_STRING);
$token2 = new Token('string');

Assert::true($token->isSame($token));
Assert::false($token->isSame($token2));


text:
package config

import (
	"errors"
	"flag"
	"fmt"
	"time"

	"code.cloudfoundry.org/lager"
	"code.cloudfoundry.org/lager/lagerflags"

	"github.com/pivotal-cf-experimental/service-config"
	"gopkg.in/validator.v2"
)

type Config struct {
	Proxy      Proxy  `yaml:"Proxy" validate:"nonzero"`
	API        API    `yaml:"API" validate:"nonzero"`
	StaticDir  string `yaml:"StaticDir" validate:"nonzero"`
	HealthPort uint   `yaml:"HealthPort" validate:"nonzero"`
	Logger     lager.Logger
}

type Proxy struct {
	Port                     uint      `yaml:"Port" validate:"nonzero"`
	InactiveMysqlPort        uint      `yaml:"InactiveMysqlPort"`
	Backends                 []Backend `yaml:"Backends" validate:"min=1"`
	HealthcheckTimeoutMillis uint      `yaml:"HealthcheckTimeoutMillis" validate:"nonzero"`
	ShutdownDelaySeconds     uint      `yaml:"ShutdownDelaySeconds"`
}

type API struct {
	Port           uint     `yaml:"Port" validate:"nonzero"`
	AggregatorPort uint     `yaml:"AggregatorPort" validate:"nonzero"`
	Username       string   `yaml:"Username" validate:"nonzero"`
	Password       string   `yaml:"Password" validate:"nonzero"`
	ForceHttps     bool     `yaml:"ForceHttps"`
	ProxyURIs      []string `yaml:"ProxyURIs"`
}

type Backend struct {
	Host           string `yaml:"Host" validate:"nonzero"`
	Port           uint   `yaml:"Port" validate:"nonzero"`
	StatusPort     uint   `yaml:"StatusPort" validate:"nonzero"`
	StatusEndpoint string `yaml:"StatusEndpoint" validate:"nonzero"`
	Name           string `yaml:"Name" validate:"nonzero"`
}

func (p Proxy) HealthcheckTimeout() time.Duration {
	return time.Duration(p.HealthcheckTimeoutMillis) * time.Millisecond
}

func (p Proxy) ShutdownDelay() time.Duration {
	return time.Duration(p.ShutdownDelaySeconds) * time.Second
}

func NewConfig(osArgs []string) (*Config, error) {
	var rootConfig Config

	binaryName := osArgs[0]
	configurationOptions := osArgs[1:]

	serviceConfig := service_config.New()
	flags := flag.NewFlagSet(binaryName, flag.ExitOnError)

	lagerflags.AddFlags(flags)

	serviceConfig.AddFlags(flags)
	flags.Parse(configurationOptions)

	err := serviceConfig.Read(&rootConfig)

	rootConfig.Logger, _ = lagerflags.NewFromConfig(binaryName, lagerflags.ConfigFromFlags())

	return &rootConfig, err
}

func (c Config) Validate() error {
	rootConfigErr := validator.Validate(c)
	var errString string
	if rootConfigErr != nil {
		errString = formatErrorString(rootConfigErr, "")
	}

	// validator.Validate does not work on nested arrays
	for i, backend := range c.Proxy.Backends {
		backendsErr := validator.Validate(backend)
		if backendsErr != nil {
			errString += formatErrorString(
				backendsErr,
				fmt.Sprintf("Proxy.Backends[%d].", i),
			)
		}
	}

	if len(errString) > 0 {
		return errors.New(fmt.Sprintf("Validation errors: %s\n", errString))
	}
	return nil
}

func formatErrorString(err error, keyPrefix string) string {
	errs := err.(validator.ErrorMap)
	var errsString string
	for fieldName, validationMessage := range errs {
		errsString += fmt.Sprintf("%s%s : %s\n", keyPrefix, fieldName, validationMessage)
	}
	return errsString
}


text:
<?php

namespace pistol88\promocode\models;

use Yii;

class PromoCodeToCondition extends \yii\db\ActiveRecord
{

    public static function tableName()
    {
        return '{{%promocode_to_condition}}';
    }

    public function rules()
    {
        return [
            [['promocode_id', 'condition_id'], 'required'],
            [['promocode_id', 'condition_id'], 'integer'],
        ];
    }

    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'promocode_id' => 'ID Помокода',
            'condition_id' => 'ID Экземпляра условия',
        ];
    }

    public function getCondition()
    {
        return $this->hasOne(PromoCodeCondition::className(),['condition_id' => 'condition_id']);
    }
}


text:
#ifndef REVOLUTION_UT_BASIC_ES_H_INCLUDED
#define REVOLUTION_UT_BASIC_ES_H_INCLUDED

#include "gtest/gtest.h"
#include "basic_es.h"
#include "objective_function.h"

namespace
{
    TEST (BasicEsTest, checkInvalidInitialization)
    {
        revolution::BasicEs *bes = 0;

        bes = revolution::BasicEs::create(-1, 1, 1, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid μ";

        bes = revolution::BasicEs::create(0, 1, 1, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid μ";

        bes = revolution::BasicEs::create(1, -1, 1, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid ρ";

        bes = revolution::BasicEs::create(1, 0, 1, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid ρ";

        bes = revolution::BasicEs::create(1, 1, -1, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid λ";

        bes = revolution::BasicEs::create(1, 1, 0, kRVSelectionModeComma, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid λ";

        bes = revolution::BasicEs::create(1, 1, 1, kRVSelectionModeInvalid, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid selection op";

        bes = revolution::BasicEs::create(1, 1, 1, (RVSelectionMode)5, 0);
        ASSERT_EQ(bes, (void *)0) << "Initialization with invalid selection op";
    }
}//~ namespace

#endif /* REVOLUTION_UT_BASIC_ES_H_INCLUDED */


text:
package com.google.j2cl.benchmarks.octane.deltablue;

/** Abstract superclass for constraints having two possible output variables. */
abstract class BinaryConstraint extends Constraint {

  Variable v1;
  Variable v2;
  int direction;

  BinaryConstraint(Variable var1, Variable var2, Strength strength) {
    super(strength);
    this.v1 = var1;
    this.v2 = var2;
    this.direction = Direction.NONE;
    // for the java version we have to move the call to addConstraint()
    // to the child classes since we need to call the parent constructor
    // first and this would cause the benchmark to fail
    // this.addConstraint();
  }

  /**
   * Decides if this constraint can be satisfied and which way it should flow based on the relative
   * strength of the variables related, and record that decision.
   */
  @Override
  void chooseMethod(int mark) {
    if (v1.mark == mark) {
      direction =
          (v2.mark != mark && Strength.stronger(strength, v2.walkStrength))
              ? Direction.FORWARD
              : Direction.NONE;
    }
    if (v2.mark == mark) {
      direction =
          (v1.mark != mark && Strength.stronger(strength, v1.walkStrength))
              ? Direction.BACKWARD
              : Direction.NONE;
    }
    if (Strength.weaker(v1.walkStrength, v2.walkStrength)) {
      direction =
          Strength.stronger(strength, v1.walkStrength) ? Direction.BACKWARD : Direction.NONE;
    } else {
      direction =
          Strength.stronger(strength, v2.walkStrength) ? Direction.FORWARD : Direction.BACKWARD;
    }
  }

  /** Add this constraint to the constraint graph */
  @Override
  void addToGraph() {
    v1.addConstraint(this);
    v2.addConstraint(this);
    direction = Direction.NONE;
  }

  /** Answer true if this constraint is satisfied in the current solution. */
  @Override
  boolean isSatisfied() {
    return direction != Direction.NONE;
  }

  /** Mark the input variable with the given mark. */
  @Override
  void markInputs(int mark) {
    input().mark = mark;
  }

  /** Returns the current input variable */
  Variable input() {
    return (direction == Direction.FORWARD) ? v1 : v2;
  }

  /** Returns the current output variable */
  @Override
  Variable output() {
    return (direction == Direction.FORWARD) ? v2 : v1;
  }

  /**
   * Calculate the walkabout strength, the stay flag, and, if it is 'stay', the value for the
   * current output of this constraint. Assume this constraint is satisfied.
   */
  @Override
  void recalculate() {
    Variable ihn = input();
    Variable out = output();
    out.walkStrength = Strength.weakestOf(strength, ihn.walkStrength);
    out.stay = ihn.stay;
    if (out.stay) {
      execute();
    }
  }

  /** Record the fact that this constraint is unsatisfied. */
  @Override
  void markUnsatisfied() {
    direction = Direction.NONE;
  }

  @Override
  boolean inputsKnown(int mark) {
    Variable i = input();
    return i.mark == mark || i.stay || i.determinedBy == null;
  }

  @Override
  void removeFromGraph() {
    if (v1 != null) {
      v1.removeConstraint(this);
    }
    if (v2 != null) {
      v2.removeConstraint(this);
    }
    direction = Direction.NONE;
  }
}


text:
using System;

namespace Tulpep.InternetSimulator
{
    public static class Logging
    {
        public static void WriteAlways(string text, params object[] args)
        {
            Console.WriteLine(string.Format(text, args));
        }

        public static void WriteVerbose(string text, params object[] args)
        {
            if (Program.Options.Verbose) Console.WriteLine(string.Format(text, args));
        }
    }
}