type Macro struct {
	name   string   // The #define name.
	args   []string // Formal arguments.
	tokens []Token  // Body of macro.
}

// Tokenize turns a string into a list of Tokens; used to parse the -D flag and in tests.
func Tokenize(str string) []Token {
	t := NewTokenizer("command line", strings.NewReader(str), nil)
	var tokens []Token
	for {
		tok := t.Next()
		if tok == scanner.EOF {
			break

	return []clause.Interface{SoftDeleteQueryClause{Field: f, ZeroValue: parseZeroValueTag(f)}}
}

func parseZeroValueTag(f *schema.Field) sql.NullString {
	if v, ok := f.TagSettings["ZEROVALUE"]; ok {
		if _, err := now.Parse(v); err == nil {
			return sql.NullString{String: v, Valid: true}
		}
	}
	return sql.NullString{Valid: false}
}

type SoftDeleteQueryClause struct {
	ZeroValue sql.NullString
	Field     *schema.Field
}

fun Request.commonNewBuilder(): Request.Builder = Request.Builder(this)

fun Request.commonCacheControl(): CacheControl {
  var result = lazyCacheControl
  if (result == null) {
    result = CacheControl.parse(headers)
    lazyCacheControl = result
  }
  return result
}

internal fun canonicalUrl(url: String): String {
  // Silently replace web socket URLs with HTTP URLs.
  return when {

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.repository.metadata.io;

import java.io.IOException;

/**
 * Signals a failure to parse the metadata due to invalid syntax (e.g. non well formed XML or unknown elements).
 *
 */
public class MetadataParseException extends IOException {

    /**
     * The one-based index of the line containing the error.

    @get:OutputDirectory
    abstract val receiptFolder: DirectoryProperty

    fun buildTimestampFrom(provider: Provider<String>) {
        buildTimestamp = provider.map { buildTimestampString -> timestampFormat.parse(buildTimestampString) }
    }

    @TaskAction
    fun generate() {
        if (promotionBuild.get()) {
            logger.logBuildVersion()
        }

                                .collect(Collectors.toList());
                    } catch (final Exception e) {
                        logger.warn("Failed to parse passwords for " + url, e);
                        list = Collections.emptyList();
                    }
                    configPasswordMap.put(value, list);
                }

		SSES3SinglePartObjects := make(map[int]bool)
		for i, object := range batch {
			if kind, ok := crypto.IsEncrypted(object.UserDefined); ok && kind == crypto.S3 && !crypto.IsMultiPart(object.UserDefined) {
				ETag, err := etag.Parse(object.ETag)
				if err != nil {
					continue
				}
				if ETag.IsEncrypted() {
					SSES3SinglePartObjects[i] = true
					metadata = append(metadata, object.UserDefined)

			w.Write([]byte(http.ErrServerClosed.Error()))
			return
		}

		atomic.AddInt32(&srv.requestCount, 1)
		defer atomic.AddInt32(&srv.requestCount, -1)

		// Handle request using passed handler.
		handler.ServeHTTP(w, r)
	})

	srv.listenerMutex.Lock()
	srv.Handler = wrappedHandler
	srv.listener = listener
	srv.listenerMutex.Unlock()

	var l net.Listener = listener

def apiChangesJsonDirectory = layout.projectDirectory.dir("src/changes/accepted-changes")
def mainApiChangesJsonFile = apiChangesJsonDirectory.file("accepted-public-api-changes.json")
def acceptedViolations = AcceptedApiChanges.parse(apiChangesJsonDirectory.asFile.listFiles()
    .findAll { it.name.endsWith(".json") }
    .collect { providers.fileContents(apiChangesJsonDirectory.file(it.name)).asText.get() }
)

      else -> false
    }

val Response.commonCacheControl: CacheControl
  get() {
    var result = lazyCacheControl
    if (result == null) {
      result = CacheControl.parse(headers)
      lazyCacheControl = result
    }
    return result
  }

fun Response.commonClose() {
  body.close()
}