PHP Class FOF30\Less\Parser\Parser

__construct() public method

Constructor

public __construct ( [type] $lessc, string $sourceName = null )
$lessc	[type]
$sourceName	string	[description]

append() protected method

Append a property to the current block

protected append ( [type] $prop, [type] $pos = null ) : void
$prop	[type]
$pos	[type]
return	void

argumentDef() protected method

.. or a variable named followed by ...

protected argumentDef ( &$args, &$isVararg, [type] $delim = ',' ) : boolean
$delim	[type]
return	boolean

argumentValues() protected method

Consume a list of property values delimited by ; and wrapped in ()

protected argumentValues ( &$args, [type] $delim = ',' ) : boolean
$delim	[type]
return	boolean

assign() protected method

Consume an assignment operator Can optionally take a name that will be set to the current property name

protected assign ( string $name = null ) : boolean
$name	string	[description]
return	boolean

color() protected method

a # color

protected color ( &$out ) : boolean
return	boolean

end() protected method

Consume an end of statement delimiter

protected end ( ) : boolean
return	boolean

expHelper() protected method

Recursively parse infix equation with $lhs at precedence $minP

protected expHelper ( type $lhs, type $minP ) : string
$lhs	type	[description]
$minP	type	[description]
return	string

expression() protected method

Attempt to consume an expression.

protected expression ( &$out ) : boolean
return	boolean

expressionList() protected method

a list of expressions

protected expressionList ( &$exps ) : boolean
return	boolean

fixTags() protected method

[fixTags description]

protected fixTags ( [type] $tags ) : [type]
$tags	[type]
return	[type]

func() protected method

A css function

protected func ( &$func ) : boolean
return	boolean

genericList() protected method

[genericList description]

protected genericList ( &$out, [type] $parseItem, string $delim = "", boolean $flatten = true ) : boolean
$parseItem	[type]
$delim	string	[description]
$flatten	boolean	[description]
return	boolean

guard() protected method

[guard description]

protected guard ( &$guard ) : boolean
return	boolean

guardGroup() protected method

A bunch of guards that are and'd together

protected guardGroup ( &$guardGroup ) : boolean
return	boolean

guards() protected method

[guards description]

protected guards ( &$guards ) : boolean
return	boolean

import() protected method

an import statement

protected import ( &$out ) : boolean
return	boolean

interpolation() protected method

[interpolation description]

protected interpolation ( &$out ) : boolean
return	boolean

isDirective() protected method

[isDirective description]

protected isDirective ( string $dirname, [type] $directives ) : boolean
$dirname	string	[description]
$directives	[type]
return	boolean

keyword() protected method

Consume a keyword

protected keyword ( &$word ) : boolean
return	boolean

literal() protected method

[literal description]

protected literal ( [type] $what, [type] $eatWhitespace = null ) : boolean
$what	[type]
$eatWhitespace	[type]
return	boolean

match() protected method

Try to match something on head of buffer

protected match ( [type] $regex, &$out, [type] $eatWhitespace = null ) : boolean
$regex	[type]
$eatWhitespace	[type]
return	boolean

mediaExpression() protected method

[mediaExpression description]

protected mediaExpression ( &$out ) : boolean
return	boolean

mediaQuery() protected method

[mediaQuery description]

protected mediaQuery ( &$out ) : [type]
return	[type]

mediaQueryList() protected method

[mediaQueryList description]

protected mediaQueryList ( &$out ) : boolean
return	boolean

mixinTags() protected method

List of tags of specifying mixin path Optionally separated by > (lazy, accepts extra >)

protected mixinTags ( &$tags ) : boolean
return	boolean

openString() protected method

An unbounded string stopped by $end

protected openString ( [type] $end, &$out, [type] $nestingOpen = null, [type] $rejectStrs = null ) : boolean
$end	[type]
$nestingOpen	[type]
$rejectStrs	[type]
return	boolean

parenValue() protected method

[parenValue description]

protected parenValue ( &$out ) : boolean
return	boolean

parse() public method

Parse text

public parse ( string $buffer ) : [type]
$buffer	string	[description]
return	[type]

parseChunk() protected method

Returns false when the buffer is empty, or when there is an error. This function is called repeatedly until the entire document is parsed. This parser is most similar to a recursive descent parser. Single functions represent discrete grammatical rules for the language, and they are able to capture the text that represents those rules. Consider the function lessc::keyword(). (all parse functions are structured the same) The function takes a single reference argument. When calling the function it will attempt to match a keyword on the head of the buffer. If it is successful, it will place the keyword in the referenced argument, advance the position in the buffer, and return true. If it fails then it won't advance the buffer and it will return false. All of these parse functions are powered by lessc::match(), which behaves the same way, but takes a literal regular expression. Sometimes it is more convenient to use match instead of creating a new function. Because of the format of the functions, to parse an entire string of grammatical rules, you can chain them together using &&. But, if some of the rules in the chain succeed before one fails, then the buffer position will be left at an invalid state. In order to avoid this, lessc::seek() is used to remember and set buffer positions. Before parsing a chain, use $s = $this->seek() to remember the current position into $s. Then if a chain fails, use $this->seek($s) to go back where we started.

protected parseChunk ( ) : boolean
return	boolean

peek() protected method

Match something without consuming it

protected peek ( [type] $regex, &$out = null, [type] $from = null ) : boolean
$regex	[type]
$from	[type]
return	boolean

pop() protected method

Pop something off the stack

protected pop ( ) : [type]
return	[type]

propertyValue() public method

Consume a list of values for a property

public propertyValue ( &$value, [type] $keyName = null ) : boolean
$keyName	[type]
return	boolean

pushBlock() protected method

[pushBlock description]

protected pushBlock ( [type] $selectors = null, [type] $type = null ) : stdClass
$selectors	[type]
$type	[type]
return	stdClass

pushSpecialBlock() protected method

Push a block that doesn't multiply tags

protected pushSpecialBlock ( [type] $type ) : stdClass
$type	[type]
return	stdClass

removeComments() protected method

Remove comments from $text

protected removeComments ( [type] $text ) : [type]
$text	[type]
return	[type]

seek() protected method

Seek to a spot in the buffer or return where we are on no argument

protected seek ( [type] $where = null ) : boolean
$where	[type]
return	boolean

string() protected method

[string description]

protected string ( &$out ) : boolean
return	boolean

tag() protected method

A single tag

protected tag ( &$tag, boolean $simple = false ) : boolean
$simple	boolean	[description]
return	boolean

tagBracket() protected method

A bracketed value (contained within in a tag definition)

protected tagBracket ( &$value ) : boolean
return	boolean

tagExpression() protected method

[tagExpression description]

protected tagExpression ( &$value ) : boolean
return	boolean

tags() protected method

Consume a list of tags This accepts a hanging delimiter

protected tags ( &$tags, [type] $simple = false, [type] $delim = ',' ) : boolean
$simple	[type]
$delim	[type]
return	boolean

throwError() public method

[throwError description]

public throwError ( string $msg = "parse error", [type] $count = null ) : void
$msg	string	[description]
$count	[type]
return	void

to() protected method

Advance counter to next occurrence of $what $until - don't include $what in advance $allowNewline, if string, will be used as valid char set

protected to ( [type] $what, &$out, boolean $until = false, boolean $allowNewline = false ) : boolean
$what	[type]
$until	boolean	[description]
$allowNewline	boolean	[description]
return	boolean

unit() protected method

[unit description]

protected unit ( &$unit ) : boolean
return	boolean

value() protected method

a single value

protected value ( &$value ) : boolean
return	boolean

variable() protected method

Consume a less variable

protected variable ( &$name ) : boolean
return	boolean

whitespace() protected method

Watch some whitespace

protected whitespace ( ) : boolean
return	boolean