Index

Modules: parsexml, src/fusion/astdsl, src/fusion/btreetables, src/fusion/docutils, src/fusion/filepermissions, src/fusion/htmlparser, src/fusion/htmlparser/xmltree, src/fusion/ioutils, src/fusion/js/jsformdata, src/fusion/js/jsheaders, src/fusion/js/jssets, src/fusion/js/jsxmlhttprequest, src/fusion/js/jsxmlserializer, src/fusion/matching, src/fusion/pointers, src/fusion/pools, src/fusion/scripting, src/fusion/smartptrs.

API symbols

`$`:

• btreetables: `$`[A](t: CountTable[A]): string
• btreetables: `$`[A](t: CountTableRef[A]): string
• btreetables: `$`[A, B](t: OrderedTable[A, B]): string
• btreetables: `$`[A, B](t: OrderedTableRef[A, B]): string
• btreetables: `$`[A, B](t: Table[A, B]): string
• btreetables: `$`[A, B](t: TableRef[A, B]): string
• xmltree: `$`(n: XmlNode): string
• jssets: `$`(this: JsSet): string
• smartptrs: `$`[T](p: ConstPtr[T]): string
• smartptrs: `$`[T](p: SharedPtr[T]): string
• smartptrs: `$`[T](p: UniquePtr[T]): string

`<>`:

• xmltree: `<>`(x: untyped): untyped

`:=`:

• matching: `:=`(lhs, rhs: untyped): untyped

`==`:

• btreetables: `==`[A](s, t: CountTable[A]): bool
• btreetables: `==`[A](s, t: CountTableRef[A]): bool
• btreetables: `==`[A, B](s, t: OrderedTable[A, B]): bool
• btreetables: `==`[A, B](s, t: OrderedTableRef[A, B]): bool
• btreetables: `==`[A, B](a, b: Table[A, B]): bool
• btreetables: `==`[A, B](s, t: TableRef[A, B]): bool
• matching: `==`(idx: FieldIndex; i: SomeInteger): bool

`=`:

• smartptrs: `=`[T](dest: var SharedPtr[T]; src: SharedPtr[T])
• smartptrs: `=`[T](dest: var UniquePtr[T]; src: UniquePtr[T])

`=destroy`:

• smartptrs: `=destroy`[T](p: var SharedPtr[T])
• smartptrs: `=destroy`[T](p: var UniquePtr[T])

`?=`:

• matching: `?=`(lhs, rhs: untyped): untyped

`[]=`:

• btreetables: `[]=`[A](t: var CountTable[A]; key: A; val: int)
• btreetables: `[]=`[A](t: CountTableRef[A]; key: A; val: int)
• btreetables: `[]=`[A, B](t: var OrderedTable[A, B]; k: A; v: B)
• btreetables: `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: B)
• btreetables: `[]=`[A, B](t: var Table[A, B]; key: A; val: B)
• btreetables: `[]=`[A, B](t: TableRef[A, B]; key: A; val: B)
• jsformdata: `[]=`(this: FormData; name, value: cstring)
• jsheaders: `[]=`(this: Headers; key: cstring; value: cstring)

`[]`:

• btreetables: `[]`[A](t: CountTable[A]; key: A): int
• btreetables: `[]`[A](t: CountTableRef[A]; key: A): int
• btreetables: `[]`[A, B](t: OrderedTable[A, B]; key: A): B
• btreetables: `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B
• btreetables: `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B
• btreetables: `[]`[A, B](t: Table[A, B]; x: A): B
• btreetables: `[]`[A, B](t: var Table[A, B]; x: A): var B
• btreetables: `[]`[A, B](t: TableRef[A, B]; key: A): var B
• xmltree: `[]`(n: XmlNode; i: int): XmlNode
• xmltree: `[]`(n: var XmlNode; i: int): var XmlNode
• jsformdata: `[]`(this: FormData; name: cstring): cstring
• jsheaders: `[]`(this: Headers; key: cstring): cstring
• matching: `[]`(t: tuple; idx: static[FieldIndex]): untyped
• smartptrs: `[]`[T](p: ConstPtr[T]): lent T
• smartptrs: `[]`[T](p: SharedPtr[T]): var T
• smartptrs: `[]`[T](p: UniquePtr[T]): var T

abort:

• jsxmlhttprequest: abort(this: XMLHttpRequest)

add:

• btreetables: add[A, B](t: var OrderedTable[A, B]; key: A; val: B)
• xmltree: add(result: var string; n: XmlNode; indent = 0; indWidth = 2; addNewLines = true)
• xmltree: add(father, son: XmlNode)
• jsformdata: add(this: FormData; name: cstring; value: SomeNumber | bool | cstring)
• jsformdata: add(this: FormData; name: cstring; value: SomeNumber | bool | cstring; filename: cstring)
• jsheaders: add(this: Headers; key: cstring; value: cstring)
• jssets: add(this: JsSet; value: JsObject)

addEscaped:

• xmltree: addEscaped(result: var string; s: string)

addPrefix:

• matching: addPrefix(str, pref: string): string

allowEmptyAttribs:

• XmlParseOption.allowEmptyAttribs

allowUnquotedAttribs:

• XmlParseOption.allowUnquotedAttribs

assertMatch:

• matching: assertMatch(input, pattern: untyped): untyped

attr:

• xmltree: attr(n: XmlNode; name: string): string

attrKey:

• parsexml: attrKey(my: XmlParser): string

attrs:

• xmltree: attrs(n: XmlNode): XmlAttributes

attrs=:

• xmltree: attrs=(n: XmlNode; attr: XmlAttributes)

attrsLen:

• xmltree: attrsLen(n: XmlNode): int

attrValue:

• parsexml: attrValue(my: XmlParser): string

BlockTags:

• htmlparser: BlockTags

buildAst:

• astdsl: buildAst(children: untyped): NimNode
• astdsl: buildAst(node, children: untyped): NimNode

charData:

• parsexml: charData(my: XmlParser): string

child:

• xmltree: child(n: XmlNode; name: string): XmlNode

chmod:

• filepermissions: chmod(path: string; permissions: Natural)

clear:

• btreetables: clear[A](t: var CountTable[A])
• btreetables: clear[A](t: CountTableRef[A])
• btreetables: clear[A, B](t: var OrderedTable[A, B])
• btreetables: clear[A, B](t: OrderedTableRef[A, B])
• btreetables: clear[A, B](t: var Table[A, B])
• btreetables: clear[A, B](t: TableRef[A, B])
• xmltree: clear(n: var XmlNode)
• jsformdata: clear(this: FormData)
• jsheaders: clear(this: Headers)
• jssets: clear(this: JsSet)

clientData:

• xmltree: clientData(n: XmlNode): int

clientData=:

• xmltree: clientData=(n: XmlNode; data: int)

close:

• parsexml: close(my: var XmlParser)

ConstPtr:

• smartptrs: ConstPtr

contains:

• btreetables: contains[A](t: CountTable[A]; key: A): bool
• btreetables: contains[A](t: CountTableRef[A]; key: A): bool
• btreetables: contains[A, B](t: OrderedTable[A, B]; key: A): bool
• btreetables: contains[A, B](t: OrderedTableRef[A, B]; key: A): bool
• btreetables: contains[A, B](t: Table[A, B]; x: A): bool
• btreetables: contains[A, B](t: TableRef[A, B]; key: A): bool
• jssets: contains(this: JsSet; value: JsObject): bool

convertConstPtrToObj:

• smartptrs: convertConstPtrToObj[T](p: ConstPtr[T]): lent T

convertSharedPtrToObj:

• smartptrs: convertSharedPtrToObj[T](p: SharedPtr[T]): var T

convertUniquePtrToObj:

• smartptrs: convertUniquePtrToObj[T](p: UniquePtr[T]): var T

CountTable:

• btreetables: CountTable

CountTableRef:

• btreetables: CountTableRef

del:

• btreetables: del[A](t: var CountTable[A]; key: A)
• btreetables: del[A](t: CountTableRef[A]; key: A)
• btreetables: del[A, B](t: var OrderedTable[A, B]; key: A)
• btreetables: del[A, B](t: OrderedTableRef[A, B]; key: A)
• btreetables: del[A, B](t: var Table[A, B]; key: A)
• btreetables: del[A, B](t: TableRef[A, B]; key: A)

delete:

• btreetables: delete[A, B](t: var OrderedTable[A, B]; key: A)
• btreetables: delete[A, B](t: OrderedTableRef[A, B]; key: A)
• xmltree: delete(n: XmlNode; i: Natural)
• jsformdata: delete(this: FormData; name: cstring)
• jsheaders: delete(this: Headers; key: cstring)
• jssets: delete(this: JsSet; value: JsObject)

duplicate:

• ioutils: duplicate(oldfd: FileHandle): FileHandle

duplicateTo:

• ioutils: duplicateTo(oldfd: FileHandle; newfd: FileHandle)

elementName:

• parsexml: elementName(my: XmlParser): string

entityName:

• parsexml: entityName(my: XmlParser): string

entityToRune:

• htmlparser: entityToRune(entity: string): Rune

entityToUtf8:

• htmlparser: entityToUtf8(entity: string): string

entries:

• jsheaders: entries(this: Headers): seq[array[2, cstring]]

errAttributeValueExpected:

• XmlErrorKind.errAttributeValueExpected

errEndOfCDataExpected:

• XmlErrorKind.errEndOfCDataExpected

errEndOfCommentExpected:

• XmlErrorKind.errEndOfCommentExpected

errEqExpected:

• XmlErrorKind.errEqExpected

errGtExpected:

• XmlErrorKind.errGtExpected

errNameExpected:

• XmlErrorKind.errNameExpected

errNone:

• XmlErrorKind.errNone

errorMsg:

• parsexml: errorMsg(my: XmlParser): string
• parsexml: errorMsg(my: XmlParser; msg: string): string

errorMsgExpected:

• parsexml: errorMsgExpected(my: XmlParser; tag: string): string

errQmGtExpected:

• XmlErrorKind.errQmGtExpected

errQuoteExpected:

• XmlErrorKind.errQuoteExpected

errSemicolonExpected:

• XmlErrorKind.errSemicolonExpected

escape:

• xmltree: escape(s: string): string

expand:

• matching: expand(body: typed): untyped

FieldIndex:

• matching: FieldIndex

findAll:

• xmltree: findAll(n: XmlNode; tag: string; caseInsensitive = false): seq[XmlNode]
• xmltree: findAll(n: XmlNode; tag: string; result: var seq[XmlNode]; caseInsensitive = false)

findItFirstOpt:

• matching: findItFirstOpt(s: typed; op: untyped): untyped

findNimSrcFiles:

• docutils: findNimSrcFiles(dir: string): string

FormData:

• jsformdata: FormData

fromFilePermissions:

• filepermissions: fromFilePermissions(perm: set[FilePermission]): uint

genCodeImportAll:

• docutils: genCodeImportAll(dir: string): string

getAll:

• jsformdata: getAll(this: FormData; name: cstring): seq[cstring]

getAllResponseHeaders:

• jsxmlhttprequest: getAllResponseHeaders(this: XMLHttpRequest): cstring

getColumn:

• parsexml: getColumn(my: XmlParser): int

getFilename:

• parsexml: getFilename(my: XmlParser): string

getKindNames:

• matching: getKindNames(head: NimNode): (string, seq[string])

getLine:

• parsexml: getLine(my: XmlParser): int

getOrDefault:

• btreetables: getOrDefault[A](t: CountTable[A]; key: A; default: int = 0): int
• btreetables: getOrDefault[A](t: CountTableRef[A]; key: A; default: int): int
• btreetables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: OrderedTable[A, B]; key: A; default: B): B
• btreetables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A; default: B): B
• btreetables: getOrDefault[A, B](t: Table[A, B]; x: A): B
• btreetables: getOrDefault[A, B](t: Table[A, B]; x: A; default: B): B
• btreetables: getOrDefault[A, B](t: TableRef[A, B]; key: A): B
• btreetables: getOrDefault[A, B](t: TableRef[A, B]; key: A; default: B): B

hasKey:

• btreetables: hasKey[A](t: CountTable[A]; key: A): bool
• btreetables: hasKey[A](t: CountTableRef[A]; key: A): bool
• btreetables: hasKey[A, B](t: OrderedTable[A, B]; key: A): bool
• btreetables: hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool
• btreetables: hasKey[A, B](t: Table[A, B]; x: A): bool
• btreetables: hasKey[A, B](t: TableRef[A, B]; key: A): bool
• jsformdata: hasKey(this: FormData; name: cstring): bool
• jsheaders: hasKey(this: Headers; key: cstring): bool

hasKeyOrPut:

• btreetables: hasKeyOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var OrderedTableRef[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var Table[A, B]; key: A; val: B): bool
• btreetables: hasKeyOrPut[A, B](t: var TableRef[A, B]; key: A; val: B): bool

hasKind:

• matching: hasKind(head, kindExpr: untyped): untyped

hasKindImpl:

• matching: hasKindImpl(head: typed; kind: untyped): untyped

Headers:

• jsheaders: Headers

HTML:

• Module parsexml

HtmlTag:

• htmlparser: HtmlTag

htmlTag:

• htmlparser: htmlTag(s: string): HtmlTag
• htmlparser: htmlTag(n: XmlNode): HtmlTag

imkInfixEq:

• ItemMatchKind.imkInfixEq

imkPredicate:

• ItemMatchKind.imkPredicate

imkSubpatt:

• ItemMatchKind.imkSubpatt

inc:

• btreetables: inc[A](t: var CountTable[A]; key: A; val: Positive = 1)
• btreetables: inc[A](t: CountTableRef[A]; key: A; val = 1)

initCountTable:

• btreetables: initCountTable[A](initialSize = 64): CountTable[A]

initOrderedTable:

• btreetables: initOrderedTable[A, B](initialSize = 64): OrderedTable[A, B]

initTable:

• btreetables: initTable[A, B](initialSize = 0): Table[A, B]

InlineTags:

• htmlparser: InlineTags

innerText:

• xmltree: innerText(n: XmlNode): string

insert:

• xmltree: insert(father, son: XmlNode; index: int)

isNil:

• smartptrs: isNil[T](p: ConstPtr[T]): bool
• smartptrs: isNil[T](p: SharedPtr[T]): bool
• smartptrs: isNil[T](p: UniquePtr[T]): bool

ItemMatchKind:

• matching: ItemMatchKind

items:

• xmltree: items(n: XmlNode): XmlNode

JsSet:

• jssets: JsSet

kAlt:

• MatchKind.kAlt

keys:

• btreetables: keys[A](t: CountTable[A]): A
• btreetables: keys[A](t: CountTableRef[A]): A
• btreetables: keys[A, B](t: OrderedTable[A, B]): A
• btreetables: keys[A, B](t: OrderedTableRef[A, B]): A
• btreetables: keys[A, B](t: Table[A, B]): A
• btreetables: keys[A, B](t: TableRef[A, B]): A
• jsformdata: keys(this: FormData): seq[cstring]
• jsheaders: keys(this: Headers): seq[cstring]

keysBetween:

• btreetables: keysBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): A

keysFrom:

• btreetables: keysFrom[A, B](b: Table[A, B]; fromKey: A): A

kind:

• parsexml: kind(my: XmlParser): XmlEventKind
• xmltree: kind(n: XmlNode): XmlNodeKind

kind=:

• matching: kind=(node: var NimNode; kind: NimNodeKind)

kItem:

• MatchKind.kItem

kObject:

• MatchKind.kObject

kPairs:

• MatchKind.kPairs

kSeq:

• MatchKind.kSeq

kSet:

• MatchKind.kSet

kTuple:

• MatchKind.kTuple

KVPair:

• matching: KVPair

largest:

• btreetables: largest[A](t: CountTable[A]): tuple[key: A, val: int]
• btreetables: largest[A](t: CountTableRef[A]): (A, int)

len:

• btreetables: len[A](t: CountTable[A]): int
• btreetables: len[A](t: CountTableRef[A]): int
• btreetables: len[A, B](t: OrderedTable[A, B]): int
• btreetables: len[A, B](t: OrderedTableRef[A, B]): int
• btreetables: len[A, B](t: Table[A, B]): int
• btreetables: len[A, B](t: TableRef[A, B]): int
• xmltree: len(n: XmlNode): int
• jssets: len(this: JsSet): int

lkAll:

• SeqKeyword.lkAll

lkAny:

• SeqKeyword.lkAny

lkNone:

• SeqKeyword.lkNone

lkOpt:

• SeqKeyword.lkOpt

lkPos:

• SeqKeyword.lkPos

lkPref:

• SeqKeyword.lkPref

lkSlice:

• SeqKeyword.lkSlice

lkTrail:

• SeqKeyword.lkTrail

lkUntil:

• SeqKeyword.lkUntil

loadHtml:

• htmlparser: loadHtml(path: string): XmlNode
• htmlparser: loadHtml(path: string; errors: var seq[string]): XmlNode

makeMatchExpr:

• matching: makeMatchExpr(m: Match; mainExpr: NimNode; doRaise: bool; originalMainExpr: NimNode): tuple[expr: NimNode, vtable: VarTable, mixident: seq[string]]

makeTree:

• matching: makeTree(T: typed; patt: untyped): untyped

Match:

• matching: Match

match:

• matching: match(n: untyped): untyped

MatchError:

• matching: MatchError

matches:

• matching: matches(input, pattern: untyped): untyped

MatchKind:

• matching: MatchKind

merge:

• btreetables: merge[A](s: var CountTable[A]; t: CountTable[A])
• btreetables: merge[A](s, t: CountTableRef[A])

mgetOrPut:

• btreetables: mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: var Table[A, B]; key: A; val: B): var B
• btreetables: mgetOrPut[A, B](t: TableRef[A, B]; key: A; val: B): var B

mitems:

• xmltree: mitems(n: var XmlNode): var XmlNode

mpairs:

• btreetables: mpairs[A](t: var CountTable[A]): (A, var int)
• btreetables: mpairs[A](t: CountTableRef[A]): (A, var int)
• btreetables: mpairs[A, B](t: var OrderedTable[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: OrderedTableRef[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: var Table[A, B]): (A, var B)
• btreetables: mpairs[A, B](t: TableRef[A, B]): (A, var B)

mvalues:

• btreetables: mvalues[A](t: var CountTable[A]): var int
• btreetables: mvalues[A](t: CountTableRef[A]): var int
• btreetables: mvalues[A, B](t: var OrderedTable[A, B]): var B
• btreetables: mvalues[A, B](t: OrderedTableRef[A, B]): var B
• btreetables: mvalues[A, B](t: var Table[A, B]): var B
• btreetables: mvalues[A, B](t: TableRef[A, B]): var B

newCData:

• xmltree: newCData(cdata: string): XmlNode

newComment:

• xmltree: newComment(comment: string): XmlNode

newConstPtr:

• smartptrs: newConstPtr[T](val: sink T): ConstPtr[T]

newCountTable:

• btreetables: newCountTable[A](initialSize = 64): CountTableRef[A]
• btreetables: newCountTable[A](keys: openArray[A]): CountTableRef[A]

newElement:

• xmltree: newElement(tag: string): XmlNode

newEntity:

• xmltree: newEntity(entity: string): XmlNode

newFormData:

• jsformdata: newFormData(): FormData

newHeaders:

• jsheaders: newHeaders(): Headers

newJsSet:

• jssets: newJsSet(): JsSet
• jssets: newJsSet(items: openArray[JsObject]): JsSet

newNode:

• pools: newNode[T](p: var Pool[T]): ptr T

newOrderedTable:

• btreetables: newOrderedTable[A, B](initialSize = 64): OrderedTableRef[A, B]
• btreetables: newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]

newSharedPtr:

• smartptrs: newSharedPtr[T](val: sink T): SharedPtr[T]

newTable:

• btreetables: newTable[A, B](): TableRef[A, B]
• btreetables: newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]

newTableFrom:

• btreetables: newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]

newText:

• xmltree: newText(text: string): XmlNode

newUniquePtr:

• smartptrs: newUniquePtr[T](val: sink T): UniquePtr[T]

newVerbatimText:

• xmltree: newVerbatimText(text: string): XmlNode

newXMLHttpRequest:

• jsxmlhttprequest: newXMLHttpRequest(): XMLHttpRequest

newXMLSerializer:

• jsxmlserializer: newXMLSerializer(): XMLSerializer

newXmlTree:

• xmltree: newXmlTree(tag: string; children: openArray[XmlNode]; attributes: XmlAttributes = nil): XmlNode

next:

• parsexml: next(my: var XmlParser)

nnkFloatKinds:

• matching: nnkFloatKinds

nnkIdentKinds:

• matching: nnkIdentKinds

nnkIntKinds:

• matching: nnkIntKinds

nnkStrKinds:

• matching: nnkStrKinds

nnkTokenKinds:

• matching: nnkTokenKinds

open:

• parsexml: open(my: var XmlParser; input: Stream; filename: string; options: set[XmlParseOption] = {})
• jsxmlhttprequest: open(this: XMLHttpRequest; metod, url: cstring; async = true; user = cstring.default; password = cstring.default)

OrderedTable:

• btreetables: OrderedTable

OrderedTableRef:

• btreetables: OrderedTableRef

overrideMimeType:

• jsxmlhttprequest: overrideMimeType(this: XMLHttpRequest; mimeType: cstring)

pairs:

• btreetables: pairs[A](t: CountTable[A]): (A, int)
• btreetables: pairs[A](t: CountTableRef[A]): (A, int)
• btreetables: pairs[A, B](t: OrderedTable[A, B]): (A, B)
• btreetables: pairs[A, B](t: OrderedTableRef[A, B]): (A, B)
• btreetables: pairs[A, B](t: Table[A, B]): (A, B)
• btreetables: pairs[A, B](t: TableRef[A, B]): (A, B)
• jsformdata: pairs(this: FormData): seq[tuple[key, val: cstring]]

pairsBetween:

• btreetables: pairsBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): tuple[key: A, val: B]

pairsFrom:

• btreetables: pairsFrom[A, B](b: Table[A, B]; fromKey: A): tuple[key: A, val: B]

parseHtml:

• htmlparser: parseHtml(s: Stream): XmlNode
• htmlparser: parseHtml(s: Stream; filename: string; errors: var seq[string]): XmlNode
• htmlparser: parseHtml(html: string): XmlNode

parseMatchExpr:

• matching: parseMatchExpr(n: NimNode): Match

piName:

• parsexml: piName(my: XmlParser): string

piRest:

• parsexml: piRest(my: XmlParser): string

Pool:

• pools: Pool

pop:

• btreetables: pop[A](t: var CountTable[A]; key: A; val: var int): bool
• btreetables: pop[A](t: CountTableRef[A]; key: A; val: var int): bool
• btreetables: pop[A, B](t: var OrderedTable[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: OrderedTableRef[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: var Table[A, B]; key: A; val: var B): bool
• btreetables: pop[A, B](t: TableRef[A, B]; key: A; val: var B): bool

put:

• jsformdata: put(this: FormData; name, value, filename: cstring)

rawData:

• parsexml: rawData(my: var XmlParser): string

rawData2:

• parsexml: rawData2(my: var XmlParser): string

rawTag:

• xmltree: rawTag(n: XmlNode): string

rawText:

• xmltree: rawText(n: XmlNode): string

reportComments:

• XmlParseOption.reportComments

reportWhitespace:

• XmlParseOption.reportWhitespace

runeToEntity:

• htmlparser: runeToEntity(rune: Rune): string

send:

• jsxmlhttprequest: send(this: XMLHttpRequest; body: cstring | Node = cstring.default)

SeqKeyword:

• matching: SeqKeyword

SeqStructure:

• matching: SeqStructure

serializeToString:

• jsxmlserializer: serializeToString(this: XMLSerializer; node: Node): cstring

setRequestHeader:

• jsxmlhttprequest: setRequestHeader(this: XMLHttpRequest; key, value: cstring)
• jsxmlhttprequest: setRequestHeader(this: XMLHttpRequest; keyValuePairs: openArray[tuple[key, val: cstring]])

SharedPtr:

• smartptrs: SharedPtr

SingleTags:

• htmlparser: SingleTags

smallest:

• btreetables: smallest[A](t: CountTable[A]): tuple[key: A, val: int]
• btreetables: smallest[A](t: CountTableRef[A]): (A, int)

str:

• matching: str(node: NimNode): string

str=:

• matching: str=(node: var NimNode; val: string)

Table:

• btreetables: Table

TableRef:

• btreetables: TableRef

tag:

• xmltree: tag(n: XmlNode): string

tag=:

• xmltree: tag=(n: XmlNode; tag: string)

tagA:

• HtmlTag.tagA

tagAbbr:

• HtmlTag.tagAbbr

tagAcronym:

• HtmlTag.tagAcronym

tagAddress:

• HtmlTag.tagAddress

tagApplet:

• HtmlTag.tagApplet

tagArea:

• HtmlTag.tagArea

tagArticle:

• HtmlTag.tagArticle

tagAside:

• HtmlTag.tagAside

tagAudio:

• HtmlTag.tagAudio

tagB:

• HtmlTag.tagB

tagBase:

• HtmlTag.tagBase

tagBasefont:

• HtmlTag.tagBasefont

tagBdi:

• HtmlTag.tagBdi

tagBdo:

• HtmlTag.tagBdo

tagBig:

• HtmlTag.tagBig

tagBlockquote:

• HtmlTag.tagBlockquote

tagBody:

• HtmlTag.tagBody

tagBr:

• HtmlTag.tagBr

tagButton:

• HtmlTag.tagButton

tagCanvas:

• HtmlTag.tagCanvas

tagCaption:

• HtmlTag.tagCaption

tagCenter:

• HtmlTag.tagCenter

tagCite:

• HtmlTag.tagCite

tagCode:

• HtmlTag.tagCode

tagCol:

• HtmlTag.tagCol

tagColgroup:

• HtmlTag.tagColgroup

tagCommand:

• HtmlTag.tagCommand

tagDatalist:

• HtmlTag.tagDatalist

tagDd:

• HtmlTag.tagDd

tagDel:

• HtmlTag.tagDel

tagDetails:

• HtmlTag.tagDetails

tagDfn:

• HtmlTag.tagDfn

tagDialog:

• HtmlTag.tagDialog

tagDir:

• HtmlTag.tagDir

tagDiv:

• HtmlTag.tagDiv

tagDl:

• HtmlTag.tagDl

tagDt:

• HtmlTag.tagDt

tagEm:

• HtmlTag.tagEm

tagEmbed:

• HtmlTag.tagEmbed

tagFieldset:

• HtmlTag.tagFieldset

tagFigcaption:

• HtmlTag.tagFigcaption

tagFigure:

• HtmlTag.tagFigure

tagFont:

• HtmlTag.tagFont

tagFooter:

• HtmlTag.tagFooter

tagForm:

• HtmlTag.tagForm

tagFrame:

• HtmlTag.tagFrame

tagFrameset:

• HtmlTag.tagFrameset

tagH1:

• HtmlTag.tagH1

tagH2:

• HtmlTag.tagH2

tagH3:

• HtmlTag.tagH3

tagH4:

• HtmlTag.tagH4

tagH5:

• HtmlTag.tagH5

tagH6:

• HtmlTag.tagH6

tagHead:

• HtmlTag.tagHead

tagHeader:

• HtmlTag.tagHeader

tagHgroup:

• HtmlTag.tagHgroup

tagHr:

• HtmlTag.tagHr

tagHtml:

• HtmlTag.tagHtml

tagI:

• HtmlTag.tagI

tagIframe:

• HtmlTag.tagIframe

tagImg:

• HtmlTag.tagImg

tagInput:

• HtmlTag.tagInput

tagIns:

• HtmlTag.tagIns

tagIsindex:

• HtmlTag.tagIsindex

tagKbd:

• HtmlTag.tagKbd

tagKeygen:

• HtmlTag.tagKeygen

tagLabel:

• HtmlTag.tagLabel

tagLegend:

• HtmlTag.tagLegend

tagLi:

• HtmlTag.tagLi

tagLink:

• HtmlTag.tagLink

tagMap:

• HtmlTag.tagMap

tagMark:

• HtmlTag.tagMark

tagMenu:

• HtmlTag.tagMenu

tagMeta:

• HtmlTag.tagMeta

tagMeter:

• HtmlTag.tagMeter

tagNav:

• HtmlTag.tagNav

tagNobr:

• HtmlTag.tagNobr

tagNoframes:

• HtmlTag.tagNoframes

tagNoscript:

• HtmlTag.tagNoscript

tagObject:

• HtmlTag.tagObject

tagOl:

• HtmlTag.tagOl

tagOptgroup:

• HtmlTag.tagOptgroup

tagOption:

• HtmlTag.tagOption

tagOutput:

• HtmlTag.tagOutput

tagP:

• HtmlTag.tagP

tagParam:

• HtmlTag.tagParam

tagPre:

• HtmlTag.tagPre

tagProgress:

• HtmlTag.tagProgress

tagQ:

• HtmlTag.tagQ

tagRp:

• HtmlTag.tagRp

tagRt:

• HtmlTag.tagRt

tagRuby:

• HtmlTag.tagRuby

tagS:

• HtmlTag.tagS

tagSamp:

• HtmlTag.tagSamp

tagScript:

• HtmlTag.tagScript

tagSection:

• HtmlTag.tagSection

tagSelect:

• HtmlTag.tagSelect

tagSmall:

• HtmlTag.tagSmall

tagSource:

• HtmlTag.tagSource

tagSpan:

• HtmlTag.tagSpan

tagStrike:

• HtmlTag.tagStrike

tagStrong:

• HtmlTag.tagStrong

tagStyle:

• HtmlTag.tagStyle

tagSub:

• HtmlTag.tagSub

tagSummary:

• HtmlTag.tagSummary

tagSup:

• HtmlTag.tagSup

tagTable:

• HtmlTag.tagTable

tagTbody:

• HtmlTag.tagTbody

tagTd:

• HtmlTag.tagTd

tagTextarea:

• HtmlTag.tagTextarea

tagTfoot:

• HtmlTag.tagTfoot

tagTh:

• HtmlTag.tagTh

tagThead:

• HtmlTag.tagThead

tagTime:

• HtmlTag.tagTime

tagTitle:

• HtmlTag.tagTitle

tagToStr:

• htmlparser: tagToStr

tagTr:

• HtmlTag.tagTr

tagTrack:

• HtmlTag.tagTrack

tagTt:

• HtmlTag.tagTt

tagU:

• HtmlTag.tagU

tagUl:

• HtmlTag.tagUl

tagUnknown:

• HtmlTag.tagUnknown

tagVar:

• HtmlTag.tagVar

tagVideo:

• HtmlTag.tagVideo

tagWbr:

• HtmlTag.tagWbr

take:

• btreetables: take[A, B](t: var Table[A, B]; key: A; val: var B): bool
• btreetables: take[A, B](t: TableRef[A, B]; key: A; val: var B): bool

text:

• xmltree: text(n: XmlNode): string

text=:

• xmltree: text=(n: XmlNode; text: string)

toAccs:

• matching: toAccs(path: Path; name: NimNode; pathForType: bool): NimNode

toCountTable:

• btreetables: toCountTable[A](keys: openArray[A]): CountTable[A]

toFilePermissions:

• filepermissions: toFilePermissions(perm: Natural): set[FilePermission]

toOrderedTable:

• btreetables: toOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B]

toString:

• jssets: toString(this: JsSet): seq[cstring]

toTable:

• btreetables: toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]

toUncheckedArray:

• pointers: toUncheckedArray[T](a: ptr T): ptr UncheckedArray[T]

toXmlAttributes:

• xmltree: toXmlAttributes(keyValuePairs: varargs[tuple[key, val: string]]): XmlAttributes

UniquePtr:

• smartptrs: UniquePtr

values:

• btreetables: values[A](t: CountTable[A]): int
• btreetables: values[A](t: CountTableRef[A]): int
• btreetables: values[A, B](t: OrderedTable[A, B]): B
• btreetables: values[A, B](t: OrderedTableRef[A, B]): B
• btreetables: values[A, B](t: Table[A, B]): B
• btreetables: values[A, B](t: TableRef[A, B]): B
• jsformdata: values(this: FormData): seq[cstring]
• jsheaders: values(this: Headers): seq[cstring]

valuesBetween:

• btreetables: valuesBetween[A, B](b: Table[A, B]; fromKey: A; toKey: A): B

valuesFrom:

• btreetables: valuesFrom[A, B](b: Table[A, B]; fromKey: A): B

VarKind:

• matching: VarKind

varOfIteration:

• matching: varOfIteration(arg: untyped): untyped

VarSpec:

• matching: VarSpec

vkAlt:

• VarKind.vkAlt

vkOption:

• VarKind.vkOption

vkRegular:

• VarKind.vkRegular

vkSequence:

• VarKind.vkSequence

vkSet:

• VarKind.vkSet

withDir:

• scripting: withDir(dir: string; body: untyped): untyped

XML:

• Module parsexml

xmlAttribute:

• XmlEventKind.xmlAttribute

XmlAttributes:

• xmltree: XmlAttributes

xmlCData:

• XmlEventKind.xmlCData

xmlCharData:

• XmlEventKind.xmlCharData

xmlComment:

• XmlEventKind.xmlComment

xmlElementClose:

• XmlEventKind.xmlElementClose

xmlElementEnd:

• XmlEventKind.xmlElementEnd

xmlElementOpen:

• XmlEventKind.xmlElementOpen

xmlElementStart:

• XmlEventKind.xmlElementStart

xmlEntity:

• XmlEventKind.xmlEntity

xmlEof:

• XmlEventKind.xmlEof

xmlError:

• XmlEventKind.xmlError

XmlErrorKind:

• parsexml: XmlErrorKind

XmlEventKind:

• parsexml: XmlEventKind

xmlHeader:

• xmltree: xmlHeader

XMLHttpRequest:

• jsxmlhttprequest: XMLHttpRequest

XmlNode:

• xmltree: XmlNode

XmlNodeKind:

• xmltree: XmlNodeKind

XmlParseOption:

• parsexml: XmlParseOption

XmlParser:

• parsexml: XmlParser

xmlPI:

• XmlEventKind.xmlPI

XMLSerializer:

• jsxmlserializer: XMLSerializer

xmlSpecial:

• XmlEventKind.xmlSpecial

xmlWhitespace:

• XmlEventKind.xmlWhitespace

xnCData:

• XmlNodeKind.xnCData

xnComment:

• XmlNodeKind.xnComment

xnElement:

• XmlNodeKind.xnElement

xnEntity:

• XmlNodeKind.xnEntity

xnText:

• XmlNodeKind.xnText

xnVerbatimText:

• XmlNodeKind.xnVerbatimText