The glsl-toolkit Reference Manual

Table of Contents

The glsl-toolkit Reference Manual

This is the glsl-toolkit Reference Manual, version 1.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 11:54:45 2020 GMT+0.

1 Introduction

About GLSL-Toolkit

This is a collection of tools written to allow you to wrangle OpenGL Shader Language (GLSL) source files. The library was written for GLSL4.5 sources, but should work with higher or lower versions as well.

How To

The primary functionality that this library gives you is parsing, serialising, and walking GLSL source code.

(glsl-toolkit:parse "int a = 0;
                     void main(){
                       int b = 1;
                       a = b;
                     }")

This will lex and parse the source into an AST. You can then turn the AST back into a code representation.

(glsl-toolkit:serialize *)

The library will take certain liberties at transforming the code while parsing and printing. This is done to normalise the code and make it easier to walk and change. The semantic meaning of the code should however be preserved verbatim. If this is not the case, please file an issue.

Aside from simply printing the source out again, you can also walk over it and transform it in a syntactically and semantically useful way. This way you can refactor the code. A simple example is in order.

(glsl-toolkit:serialize
  (glsl-toolkit:walk **
    (lambda (ast context environment)
      (if (glsl-toolkit:global-identifier-p ast environment)
          (format NIL "__~a" ast)
          ast))))

The code walker provides access to a number of predicates that allow you to figure out properties of the current node and the lexical meaning of identifiers. Have a look at the symbol index for the various predicate functions.

Finally, the library provides a way to merge individual shader files together. It does so while attempting to either unify or rename global identifiers that might clash. This is useful when multiple shader effects need to be chained together in a single shader pass.

(glsl-toolkit:merge-shader-sources '("
  out layout (location = 0) vec4 position;
  
  void foo();
  
  void main(){
    position += vec4(1, 2, 3, 4);
  }" "
  out layout (location = 0) vec4 pos;
  in layout (location = 0) vec4 col;
  
  void foo(){
    a();
  }
  
  void main(){
    pos += col;
  }"))

The merging does not come without its caveats. At times, it may be impossible to merge due to conflicting type declarations, and other times the system may not recognise a possible merge due to name or qualifier mismatch. While it should work for most cases, some exotic cases are likely to fail at may need manual intervention.

Some caveats exist in the parser as well. Since we cannot implement the behaviour of the preprocessor ourselves, we instead must opt for allowing preprocessor directives verbatim at certain points in the parse tree. We opt for allowing them at any point where a statement or declaration might occur, but not within expressions.

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 glsl-toolkit

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://Shirakumo.github.io/glsl-toolkit/

Source Control

(:git "https://github.com/shirakumo/glsl-toolkit.git")

Bug Tracker

https://github.com/Shirakumo/glsl-toolkit/issues

License

zlib

Description

A library to parse and modify OpenGL Shader Language (GLSL) source code

Version

1.0.0

Dependencies

• documentation-utils
• parse-float
• trivial-indent
• cl-ppcre

Source

glsl-toolkit.asd (file)

Components

• package.lisp (file)
• toolkit.lisp (file)
• parser.lisp (file)
• grammar.lisp (file)
• printer.lisp (file)
• walker.lisp (file)
• merge.lisp (file)
• sexpr.lisp (file)
• documentation.lisp (file)

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.

3.1 Lisp

3.1.1 glsl-toolkit.asd

Location

glsl-toolkit.asd

Systems

glsl-toolkit (system)

3.1.2 glsl-toolkit/package.lisp

Parent

glsl-toolkit (system)

Location

package.lisp

Packages

• glsl-toolkit
• glsl-parser-rules

3.1.3 glsl-toolkit/toolkit.lisp

Dependency

package.lisp (file)

Parent

glsl-toolkit (system)

Location

toolkit.lisp

Exported Definitions

• *glsl-keyword-symbols* (special variable)
• *glsl-keywords* (special variable)

Internal Definitions

• enlist (function)
• find-any (function)
• mapcar* (function)
• merge-plists (function)
• starts-with (function)

3.1.4 glsl-toolkit/parser.lisp

Dependency

toolkit.lisp (file)

Parent

glsl-toolkit (system)

Location

parser.lisp

Exported Definitions

• advance (compiler macro)
• advance (function)
• backtrack (compiler macro)
• backtrack (function)
• compile-rule (function)
• consume (compiler macro)
• consume (function)
• consume-any (function)
• consume-notany (function)
• consume-string (function)
• consume-whitespace (function)
• define-object (macro)
• define-reference (macro)
• define-rule (macro)
• end-of-tokens-p (compiler macro)
• end-of-tokens-p (function)
• lex (function)
• no-value (symbol macro)
• normalize-shader-source (function)
• parse (function)
• peek (compiler macro)
• peek (function)
• remove-rule (function)
• rule (function)
• (setf rule) (function)
• trace-parse (function)
• untrace-parse (function)
• with-token-input (macro)

Internal Definitions

• *max-index* (special variable)
• *token-array* (special variable)
• *token-index* (special variable)
• *trace-level* (special variable)
• *traced* (special variable)
• call-traced-function (function)
• check-parse-complete (function)
• discover-expr-around (function)
• index (type)
• newline-p (function)
• trace-parse-func (function)
• untrace-parse-func (function)

3.1.5 glsl-toolkit/grammar.lisp

Dependency

parser.lisp (file)

Parent

glsl-toolkit (system)

Location

grammar.lisp

Exported Definitions

• ! (function)
• != (function)
• % (function)
• %= (function)
• & (function)
• && (function)
• &= (function)
• ( (function)
• ) (function)
• * (function)
• *= (function)
• + (function)
• ++ (function)
• += (function)
• , (function)
• - (function)
• -- (function)
• -= (function)
• . (function)
• / (function)
• /= (function)
• ∶ (function)
• ; (function)
• < (function)
• << (function)
• <<= (function)
• <= (function)
• = (function)
• == (function)
• > (function)
• >= (function)
• >> (function)
• >>= (function)
• ? (function)
• [ (function)
• ] (function)
• ^ (function)
• ^= (function)
• ^^ (function)
• addition (function)
• array-initializer (function)
• array-modifier (function)
• array-specifier (function)
• assignment (function)
• assignment-expression (function)
• basic-type (function)
• bit-inversion (function)
• bitwise-and (function)
• boolean-constant (function)
• break (function)
• call-modifier (function)
• case-label (function)
• compound-statement (function)
• condition (function)
• condition-declarator (function)
• conditional (function)
• conditional-expression (function)
• constant-expression (function)
• continue (function)
• decimal-token (function)
• declaration (function)
• decrement-modifier (function)
• discard (function)
• division (function)
• do-statement (function)
• equal (function)
• exclusive-or (function)
• expression (function)
• expression-statement (function)
• field-modifier (function)
• float-constant (function)
• float-token (function)
• for-statement (function)
• function-declaration (function)
• function-definition (function)
• function-prototype (function)
• greater-equal-than (function)
• greater-than (function)
• hexadecimal-token (function)
• identifier (function)
• identifier-token (function)
• inclusive-or (function)
• increment-modifier (function)
• initializer (function)
• instance-name (function)
• integer-constant (function)
• integer-token (function)
• interface-declaration (function)
• interpolation-qualifier (function)
• invariant-qualifier (function)
• inversion (function)
• iteration-statement (function)
• jump-statement (function)
• keyword-token (function)
• layout-qualifier (function)
• layout-qualifier-id (function)
• left-shift (function)
• less-equal-than (function)
• less-than (function)
• logical-and (function)
• logical-or (function)
• logical-xor (function)
• modified-reference (function)
• modulus (function)
• multiple-expressions (function)
• multiplication (function)
• negation (function)
• not-equal (function)
• octal-token (function)
• operator (function)
• parameter-declaration (function)
• postfix-expression (function)
• precise-qualifier (function)
• precision-declaration (function)
• precision-qualifier (function)
• prefix-decrement (function)
• prefix-increment (function)
• preprocessor-directive (function)
• preprocessor-token (function)
• primary-expression (function)
• reference-modifier (function)
• return (function)
• right-shift (function)
• same-+ (function)
• selection-statement (function)
• shader (function)
• simple-statement (function)
• statement (function)
• storage-qualifier (function)
• struct-declaration (function)
• struct-declarator (function)
• struct-field-declarator (function)
• struct-specifier (function)
• subroutine-qualifier (function)
• subtraction (function)
• switch-statement (function)
• token (function)
• tokenize (function)
• type-name (function)
• type-qualifier (function)
• type-specifier (function)
• type-specifier-nonarray (function)
• unary-expression (function)
• variable-declaration (function)
• variable-initializer (function)
• while-statement (function)
• whitespace (function)
• { (function)
• | (function)
• |= (function)
• || (function)
• } (function)

Internal Definitions

• define-binary-op (macro)
• define-operator-objects (macro)

3.1.6 glsl-toolkit/printer.lisp

Dependency

grammar.lisp (file)

Parent

glsl-toolkit (system)

Location

printer.lisp

Exported Definitions

• define-serialization (macro)
• define-serializer (macro)
• indent (function)
• remove-serializer (function)
• serialize (function)
• serialize-part (function)
• serializer (function)
• (setf serializer) (function)
• sformat (compiler macro)
• sformat (function)
• with-indentation (macro)

Internal Definitions

• %format-object (function)
• *indent* (special variable)
• *serialize-stream* (special variable)
• *serializers* (special variable)
• compile-format-string (function)

3.1.7 glsl-toolkit/walker.lisp

Dependency

printer.lisp (file)

Parent

glsl-toolkit (system)

Location

walker.lisp

Exported Definitions

• binding (function)
• (setf binding) (function)
• constant-p (function)
• control-flow-p (function)
• declaration-p (function)
• define-binary-op-walker (macro)
• define-empty-op-walker (macro)
• define-unary-op-walker (macro)
• define-walker (macro)
• define-walking-body (macro)
• environment (class)
• expression-p (function)
• function-identifier-p (function)
• global-identifier-p (function)
• identifier-p (function)
• keyword-p (function)
• local-identifier-p (function)
• make-environment (function)
• preprocessor-p (function)
• remove-walker (function)
• root-environment-p (function)
• statement-p (function)
• variable-identifier-p (function)
• walk (function)
• walk-part (function)
• walker (function)
• (setf walker) (function)

Internal Definitions

• *walkers* (special variable)
• bindings (method)
• root (method)

3.1.8 glsl-toolkit/merge.lisp

Dependency

walker.lisp (file)

Parent

glsl-toolkit (system)

Location

merge.lisp

Exported Definitions

• matching-declarators-p (function)
• matching-qualifiers-p (function)
• matching-specifiers-p (function)
• merge-shader-sources (function)
• merge-shaders (function)
• uniquify (function)

Internal Definitions

• *unique-counter* (special variable)
• find-direction-qualifier (function)
• find-layout-qualifier (function)
• find-matching-layout-declaration (function)
• handle-declaration (function)
• handle-identifier (function)
• split-shader-into-groups (function)

3.1.9 glsl-toolkit/sexpr.lisp

Dependency

merge.lisp (file)

Parent

glsl-toolkit (system)

Location

sexpr.lisp

Internal Definitions

• *sexpr-transforms* (special variable)
• define-expr-binary (macro)
• define-sexpr-comparator (macro)
• define-sexpr-transform (macro)
• remove-sexpr-transform (function)
• separate-qualifier-specifier (function)
• sexpr->glsl-ast (function)
• sexpr-transform (function)
• (setf sexpr-transform) (function)
• symbol->identifier (function)
• with-glsl-syntax (macro)

3.1.10 glsl-toolkit/documentation.lisp

Dependency

sexpr.lisp (file)

Parent

glsl-toolkit (system)

Location

documentation.lisp

4 Packages

Packages are listed by definition order.

4.1 glsl-toolkit

Source

package.lisp (file)

Nickname

org.shirakumo.trial.glsl

Use List

common-lisp

Exported Definitions

• *glsl-keyword-symbols* (special variable)
• *glsl-keywords* (special variable)
• advance (compiler macro)
• advance (function)
• backtrack (compiler macro)
• backtrack (function)
• binding (function)
• (setf binding) (function)
• compile-rule (function)
• constant-p (function)
• consume (compiler macro)
• consume (function)
• consume-any (function)
• consume-notany (function)
• consume-string (function)
• consume-whitespace (function)
• control-flow-p (function)
• declaration-p (function)
• define-binary-op-walker (macro)
• define-empty-op-walker (macro)
• define-object (macro)
• define-reference (macro)
• define-rule (macro)
• define-serialization (macro)
• define-serializer (macro)
• define-unary-op-walker (macro)
• define-walker (macro)
• define-walking-body (macro)
• end-of-tokens-p (compiler macro)
• end-of-tokens-p (function)
• environment (class)
• expression-p (function)
• function-identifier-p (function)
• global-identifier-p (function)
• identifier-p (function)
• indent (function)
• keyword-p (function)
• lex (function)
• local-identifier-p (function)
• make-environment (function)
• matching-declarators-p (function)
• matching-qualifiers-p (function)
• matching-specifiers-p (function)
• merge-shader-sources (function)
• merge-shaders (function)
• no-value (symbol macro)
• normalize-shader-source (function)
• parse (function)
• peek (compiler macro)
• peek (function)
• preprocessor-p (function)
• remove-rule (function)
• remove-serializer (function)
• remove-walker (function)
• root-environment-p (function)
• rule (function)
• (setf rule) (function)
• serialize (function)
• serialize-part (function)
• serializer (function)
• (setf serializer) (function)
• sformat (compiler macro)
• sformat (function)
• statement-p (function)
• trace-parse (function)
• uniquify (function)
• untrace-parse (function)
• variable-identifier-p (function)
• walk (function)
• walk-part (function)
• walker (function)
• (setf walker) (function)
• with-indentation (macro)
• with-token-input (macro)

Internal Definitions

• %format-object (function)
• *indent* (special variable)
• *max-index* (special variable)
• *serialize-stream* (special variable)
• *serializers* (special variable)
• *sexpr-transforms* (special variable)
• *token-array* (special variable)
• *token-index* (special variable)
• *trace-level* (special variable)
• *traced* (special variable)
• *unique-counter* (special variable)
• *walkers* (special variable)
• bindings (generic function)
• bindings (method)
• call-traced-function (function)
• check-parse-complete (function)
• compile-format-string (function)
• define-binary-op (macro)
• define-expr-binary (macro)
• define-operator-objects (macro)
• define-sexpr-comparator (macro)
• define-sexpr-transform (macro)
• discover-expr-around (function)
• enlist (function)
• find-any (function)
• find-direction-qualifier (function)
• find-layout-qualifier (function)
• find-matching-layout-declaration (function)
• handle-declaration (function)
• handle-identifier (function)
• index (type)
• mapcar* (function)
• merge-plists (function)
• newline-p (function)
• remove-sexpr-transform (function)
• root (generic function)
• root (method)
• separate-qualifier-specifier (function)
• sexpr->glsl-ast (function)
• sexpr-transform (function)
• (setf sexpr-transform) (function)
• split-shader-into-groups (function)
• starts-with (function)
• symbol->identifier (function)
• trace-parse-func (function)
• untrace-parse-func (function)
• with-glsl-syntax (macro)

4.2 glsl-parser-rules

Source

package.lisp (file)

Nickname

org.shirakumo.trial.glsl.parser.rules

Exported Definitions

• ! (function)
• != (function)
• % (function)
• %= (function)
• & (function)
• && (function)
• &= (function)
• ( (function)
• ) (function)
• * (function)
• *= (function)
• + (function)
• ++ (function)
• += (function)
• , (function)
• - (function)
• -- (function)
• -= (function)
• . (function)
• / (function)
• /= (function)
• ∶ (function)
• ; (function)
• < (function)
• << (function)
• <<= (function)
• <= (function)
• = (function)
• == (function)
• > (function)
• >= (function)
• >> (function)
• >>= (function)
• ? (function)
• [ (function)
• ] (function)
• ^ (function)
• ^= (function)
• ^^ (function)
• addition (function)
• array-initializer (function)
• array-modifier (function)
• array-specifier (function)
• assignment (function)
• assignment-expression (function)
• basic-type (function)
• bit-inversion (function)
• bitwise-and (function)
• boolean-constant (function)
• break (function)
• call-modifier (function)
• case-label (function)
• compound-statement (function)
• condition (function)
• condition-declarator (function)
• conditional (function)
• conditional-expression (function)
• constant-expression (function)
• continue (function)
• decimal-token (function)
• declaration (function)
• decrement-modifier (function)
• discard (function)
• division (function)
• do-statement (function)
• equal (function)
• exclusive-or (function)
• expression (function)
• expression-statement (function)
• field-modifier (function)
• float-constant (function)
• float-token (function)
• for-statement (function)
• function-declaration (function)
• function-definition (function)
• function-prototype (function)
• greater-equal-than (function)
• greater-than (function)
• hexadecimal-token (function)
• identifier (function)
• identifier-token (function)
• inclusive-or (function)
• increment-modifier (function)
• initializer (function)
• instance-name (function)
• integer-constant (function)
• integer-token (function)
• interface-declaration (function)
• interpolation-qualifier (function)
• invariant-qualifier (function)
• inversion (function)
• iteration-statement (function)
• jump-statement (function)
• keyword-token (function)
• layout-qualifier (function)
• layout-qualifier-id (function)
• left-shift (function)
• less-equal-than (function)
• less-than (function)
• logical-and (function)
• logical-or (function)
• logical-xor (function)
• modified-reference (function)
• modulus (function)
• multiple-expressions (function)
• multiplication (function)
• negation (function)
• not-equal (function)
• octal-token (function)
• operator (function)
• parameter-declaration (function)
• postfix-expression (function)
• precise-qualifier (function)
• precision-declaration (function)
• precision-qualifier (function)
• prefix-decrement (function)
• prefix-increment (function)
• preprocessor-directive (function)
• preprocessor-token (function)
• primary-expression (function)
• reference-modifier (function)
• return (function)
• right-shift (function)
• same-+ (function)
• selection-statement (function)
• shader (function)
• simple-statement (function)
• statement (function)
• storage-qualifier (function)
• struct-declaration (function)
• struct-declarator (function)
• struct-field-declarator (function)
• struct-specifier (function)
• subroutine-qualifier (function)
• subtraction (function)
• switch-statement (function)
• token (function)
• tokenize (function)
• type-name (function)
• type-qualifier (function)
• type-specifier (function)
• type-specifier-nonarray (function)
• unary-expression (function)
• variable-declaration (function)
• variable-initializer (function)
• while-statement (function)
• whitespace (function)
• { (function)
• | (function)
• |= (function)
• || (function)
• } (function)

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

5.1 Exported definitions

5.1.1 Special variables

Special Variable: *glsl-keyword-symbols*

List to all the keywords in GLSL shader files but as interned and upcased keyword symbols.

See *GLSL-KEYWORDS*

Package

glsl-toolkit

Source

toolkit.lisp (file)

Special Variable: *glsl-keywords*

List to all the keywords in GLSL shader files.

This does not include terminals and other keywords such as {}/*+ etc.

Package

glsl-toolkit

Source

toolkit.lisp (file)

5.1.2 Symbol macros

Symbol Macro: no-value

Package

glsl-toolkit

Source

parser.lisp (file)

Expansion

(quote glsl-toolkit:no-value)

5.1.3 Macros

Macro: define-binary-op-walker TYPE

Define a walker for a binary AST object.

This walker recurses over the left and right nodes in the object and returns a fresh value constructed from them.

Package

glsl-toolkit

Source

walker.lisp (file)

Macro: define-empty-op-walker TYPE

Define a walker for an empty AST object.

This walker function does nothing but construct a fresh return value.

Package

glsl-toolkit

Source

walker.lisp (file)

Macro: define-object NAME RULE &body TRANSFORM

Defines a parsing object.

The RULE should be a parsing rule to match against. It should probably contain calls to the V rule in order to populate the V values list. This list is used to store the return values of the object.

TRANSFORM is an optional list of forms to be evaluated to transform the values list on a successful match. It acts as an implicit PROGN and the last value is returned as the value of the rule.

If no TRANSFORM is given, the return value is the V values list prepended with the name of the rule.

See DEFINE-RULE

Package

glsl-toolkit

Source

parser.lisp (file)

Macro: define-reference NAME &body RULES

Defines a reference parsing rule.

The body should be a number of sub-rules that may be matched in order to match this rule. Either the value stored in V by the V function, or the return value of the first matching sub-rule is returned.

See DEFINE-RULE

Package

glsl-toolkit

Source

parser.lisp (file)

Macro: define-rule NAME &body BODY

Defines a new parsing rule of the given name.

This will create a function definition in the ORG.SHIRAKUMO.TRIAL.GLSL.RULES package by re-interning the symbol in that package.

A default lexical binding named V is provided.

See DEFINE-REFERENCE
See DEFINE-OBJECT

Package

glsl-toolkit

Source

parser.lisp (file)

Macro: define-serialization TYPE ARGS &body BODY

Convenience function to define the serialization of AST objects of the given type.

ARGS must be a lambda-list to destructure the contents of the
AST object.

See SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Macro: define-serializer TYPE (OBJECT) &body BODY

Convenience function to define a serializer function for AST objects of the given type.

See SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Macro: define-unary-op-walker TYPE

Define a walker for a unary AST object.

This walker recurses over the single node in the object and returns a fresh value constructed from it.

Package

glsl-toolkit

Source

walker.lisp (file)

Macro: define-walker TYPE (AST FUNC ENV) &body BODY

Define a new walker function that is responsible for walking over a particular type of AST object node.

See *WALKERS*
See WALKER
See DEFINE-WALKING-BODY

Package

glsl-toolkit

Source

walker.lisp (file)

Macro: define-walking-body TYPE ARGS &body BODY

Convenience definition macro.

The ARGS should be a destructuring-bind lambda-list to destructure the contents of the object.

The body should be forms that provide the values to use in the resulting AST object. The last value should be the tail of the object’s list. Thus this is about equivalent to

(define-walker type (o)
(destructuring-bind .. (o)
(list* ’type body)))

Within the body the WALK function is rebound to one that can be conveniently used to recursively walk the AST. It only needs the new node to walk over. It optionally takes a new environment to supply.

You can reach the other function values like the full AST, the walk function, and the environment by changing the type to a list and providing the binding symbols as keyword arguments in it with :KEY :FUNC and :ENV.

See DEFINE-WALKER

Package

glsl-toolkit

Source

walker.lisp (file)

Macro: with-indentation (&optional STEP) &body BODY

Makes sure the body is evaluated with an increased indentation level.

See *INDENT*
See INDENT

Package

glsl-toolkit

Source

printer.lisp (file)

Macro: with-token-input VECTOR &body BODY

Readies the environment for token parsing.

This binds *TOKEN-ARRAY* to the given vector and binds *TOKEN-INDEX* to 0.

See *TOKEN-ARRAY*
See *TOKEN-INDEX*

Package

glsl-toolkit

Source

parser.lisp (file)

5.1.4 Compiler macros

Compiler Macro: advance &optional OFFSET

Package

glsl-toolkit

Source

parser.lisp (file)

Compiler Macro: backtrack &optional OFFSET

Package

glsl-toolkit

Source

parser.lisp (file)

Compiler Macro: consume ()

Package

glsl-toolkit

Source

parser.lisp (file)

Compiler Macro: end-of-tokens-p ()

Package

glsl-toolkit

Source

parser.lisp (file)

Compiler Macro: peek &optional OFFSET

Package

glsl-toolkit

Source

parser.lisp (file)

Compiler Macro: sformat STRING &rest ARGS

Package

glsl-toolkit

Source

printer.lisp (file)

5.1.5 Functions

Function: ! ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: != ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: % ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: %= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: & ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: && ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: &= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ( ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ) ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: * ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: *= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: + ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ++ ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: += ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: , ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: - ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: -- ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: -= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: . ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: / ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: /= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: : ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ; ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: < ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: << ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: <<= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: <= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: = ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: == ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: > ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: >= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: >> ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: >>= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ? ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: [ ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ] ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ^ ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ^= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: ^^ ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: addition ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: advance &optional OFFSET

Advances the current token index.

See *TOKEN-INDEX*
See BACKTRACK

Package

glsl-toolkit

Source

parser.lisp (file)

Function: array-initializer ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: array-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: array-specifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: assignment ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: assignment-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: backtrack &optional OFFSET

Reduces the current token index.

See *TOKEN-INDEX*
See ADVANCE

Package

glsl-toolkit

Source

parser.lisp (file)

Function: basic-type ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: binding NAME ENVIRONMENT

Accessor to the binding in the environment for the given name.

See BINDINGS
See ENVIRONMENT

Package

glsl-toolkit

Source

walker.lisp (file)

Writer

(setf binding) (function)

Function: (setf binding) VALUE NAME ENVIRONMENT

Package

glsl-toolkit

Source

walker.lisp (file)

Reader

binding (function)

Function: bit-inversion ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: bitwise-and ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: boolean-constant ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: break ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: call-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: case-label ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: compile-rule RULE

Compile the rule s-expression.

The following types are handled specially:
- NULL NIL is returned
- KEYWORD Attempts to match a token that is EQ to this keyword. On success returns the keyword.
- SYMBOL Attempts to match the rule given named by the symbol. Returns whatever the rule returns.
- CHARACTER Attempts to match a token that is EQL to this character. Returns the character on match.
- STRING Attempts to match the string against the tokens. Returns the string on successful match.
- CONS One of the following compound, identified by the first symbol.
- AND Matches if all of the sub-rules match. Returns the last rule’s return value on successful match. - OR Matches if any of the sub-rules match.
Returns the first successful rule’s return value. - NOTANY Matches if none of the choices match.
Returns the token that did not match.
- ANY Matches if any of the choices match.
Returns the token that did match.
- WHEN Performs all the other sub-rules only if the first sub-rule matches. Returns the last sub-rule’s return value.
- V Makes sure the result of the sub-rule is added to the values list if the sub-rule matches. Returns what the sub-rule returned.
- * Repeatedly matches the sub-rule as many times as possible. Returns T.
- + Attempts to match the sub-rule at least once. Returns T on success.
- ? Attempts to match the sub-rule. If it does not match the secondary form is returned, or NO-VALUE. - ! Evaluates the sub-rule and returns its result, but always resets the token index to its initial value. - Otherwise the rule is returned unchanged.

See CONSUME-STRING
See CONSUME-ANY
See CONSUME-NOTANY
See DEFINE-RULE

Package

glsl-toolkit

Source

parser.lisp (file)

Function: compound-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: condition ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: condition-declarator ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: conditional ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: conditional-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: constant-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: constant-p VALUE ENVIRONMENT

Returns T if the given AST node is a constant value.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: consume ()

Returns the token at the current index and advances the index by one.

See PEEK
See ADVANCE

Package

glsl-toolkit

Source

parser.lisp (file)

Function: consume-any CHOICES

Consume any of the tokens in the choices sequence, if possible.

If a token matches, it is returned. Otherwise NIL is returned instead. The index is only modified if a match occurs.

Package

glsl-toolkit

Source

parser.lisp (file)

Function: consume-notany CHOICES

Consume any token that is not one of the tokens in the choices sequence.

If a token matches, it is returned. Otherwise NIL is
returned instead. The index is only modified if a match
occurs.

Package

glsl-toolkit

Source

parser.lisp (file)

Function: consume-string STRING

Attempts to consume the given string from the token array.

If the string matches, it is returned. Otherwise, NIL is returned instead. If the match succeeds, the token index is modified. Otherwise it is reset to the point where it was before the match was attempted.

Package

glsl-toolkit

Source

parser.lisp (file)

Function: consume-whitespace ()

Consumes all spaces and newlines in the token array from the current position on.

Package

glsl-toolkit

Source

parser.lisp (file)

Function: continue ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: control-flow-p VALUE ENVIRONMENT

Returns T if the given AST node is a control-flow instruction.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: decimal-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: declaration-p VALUE ENVIRONMENT

Returns T if the given AST node is a declaration statement.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: decrement-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: discard ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: division ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: do-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: end-of-tokens-p ()

Returns true if the end of the token array has been reached.

See *TOKEN-ARRAY*
See *TOKEN-INDEX*

Package

glsl-toolkit

Source

parser.lisp (file)

Function: equal ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: exclusive-or ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: expression-p VALUE ENVIRONMENT

Returns T if the given AST node is an expression.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: expression-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: field-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: float-constant ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: float-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: for-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: function-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: function-definition ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: function-identifier-p VALUE ENVIRONMENT

Returns T if the given AST node is an identifier for a function.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: function-prototype ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: global-identifier-p VALUE ENVIRONMENT

Returns T if the given AST node is an identifier that refers to a global definition.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: greater-equal-than ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: greater-than ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: hexadecimal-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: identifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: identifier-p VALUE ENVIRONMENT

Returns T if the given AST node might be an identifier.

This is not always accurate, as some identifiers can also be types at the same time. It thus depends on the context.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: identifier-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: inclusive-or ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: increment-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: indent &optional OFFSET

Starts a fresh line and emits as many spaces as the *INDENT* variable dictates.

Package

glsl-toolkit

Source

printer.lisp (file)

Function: initializer ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: instance-name ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: integer-constant ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: integer-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: interface-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: interpolation-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: invariant-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: inversion ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: iteration-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: jump-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: keyword-p VALUE ENVIRONMENT

Returns T if the given AST node is a GLSL keyword.

See *GLSL-KEYWORD-SYMBOLS*

Package

glsl-toolkit

Source

walker.lisp (file)

Function: keyword-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: layout-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: layout-qualifier-id ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: left-shift ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: less-equal-than ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: less-than ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: lex INPUT &optional TOPLEVEL-RULE

Lex the input string into a token array for use in parsing.

See NORMALIZE-SHADER-SOURCE
See RULE
See PARSE

Package

glsl-toolkit

Source

parser.lisp (file)

Function: local-identifier-p VALUE ENVIRONMENT

Returns T if the given AST node is an identifier that refers to a local definition.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: logical-and ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: logical-or ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: logical-xor ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: make-environment &optional PARENT

Create a new environment object.

If not parent environment is passed in, the environment is assumed to be a top-level root environment.

See ENVIRONMENT

Package

glsl-toolkit

Source

walker.lisp (file)

Function: matching-declarators-p A B

Returns true if the two variable declarations are considered to match.

This is true if:
- The first of both lists (qualifiers) match by MATCHING-QUALIFIERS-P - The second of both lists (specifiers) match by MATCHING-SPECIFIERS-P - The fourth of both lists (array-identifiers) match by EQUAL

The third of both lists (identifiers) must not match.
The fifth of both lists (initializers) must not match.

Package

glsl-toolkit

Source

merge.lisp (file)

Function: matching-qualifiers-p A B

Returns true if the two given qualifier lists are considered to match.

The following qualifier parts are not considered:
:HIGHP :MEDIUMP :LOWP :INVARIANT :PRECISE :SMOOTH :FLAT :NOPERSPECTIVE

All other qualifiers must match by EQUAL, but don’t have to be
in the same order.

See https://www.khronos.org/opengl/wiki/Shader_Compilation#Qualifier_matching

Package

glsl-toolkit

Source

merge.lisp (file)

Function: matching-specifiers-p A B

Returns true if the two given specifier lists are considered to match.

In order to match, the two lists have to be EQUAL.

Package

glsl-toolkit

Source

merge.lisp (file)

Function: merge-shader-sources SOURCES &optional TO

Convenience function to merge the sources of multiple shaders into a single one.

Each source may be a string, pathname, or shader AST.

See PARSE
See MERGE-SHADERS
See SERIALIZE

Package

glsl-toolkit

Source

merge.lisp (file)

Function: merge-shaders &rest SHADERS

Merge the given shader ASTs into a single AST.

The top-level AST nodes must be AST objects of type SHADER.

The merging will attempt to conflate declarations where possible and rename variables where necessary, in order to create a single shader that is internally consistent.

It also emits a single main function at the end, which does nothing but call the main function of each sub-shader in the sequence that the shaders were passed.

See HANDLE-DECLARATION
See HANDLE-IDENTIFIER
See WALK
See MERGE-SHADER-SOURCES

Package

glsl-toolkit

Source

merge.lisp (file)

Function: modified-reference ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: modulus ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: multiple-expressions ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: multiplication ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: negation ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: normalize-shader-source INPUT

Attempts to normalise the shader source code.

This does the following:
- Removes any and all comments from the code
- Handles the backslash-before-newline trick to get multiple lines to act as one.
- Converts CRLF/LFCR/LFLF/CRCR into NEWLINE
- Converts TAB to SPACE
- Converts consecutive whitespace into singular whitespace while preserving newlines.

The input may be one of the following types:
- PATHNAME
- STRING
- STREAM

See NEWLINE-P

Package

glsl-toolkit

Source

parser.lisp (file)

Function: not-equal ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: octal-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: operator ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: parameter-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: parse INPUT &optional TOPLEVEL-RULE

Parses the given GLSL shader source input into an AST.

The input may be of the following types:
- STRING STREAM PATHNAME
The input is lexed before parsing as by LEX
- LIST
The input is converted into a vector
- VECTOR
The input is parsed by the given toplevel parsing rule.

See LEX
See RULE

Package

glsl-toolkit

Source

parser.lisp (file)

Function: peek &optional OFFSET

Returns the token at the index relative to the current position.

See *TOKEN-ARRAY*
See *TOKEN-INDEX*

Package

glsl-toolkit

Source

parser.lisp (file)

Function: postfix-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: precise-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: precision-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: precision-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: prefix-decrement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: prefix-increment ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: preprocessor-directive ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: preprocessor-p VALUE ENVIRONMENT

Returns T if the given AST node is a preprocessor instruction.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: preprocessor-token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: primary-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: reference-modifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: remove-rule NAME

Removes the parsing rule of the given name.

Package

glsl-toolkit

Source

parser.lisp (file)

Function: remove-serializer TYPE

Removes the serializer function for AST objects of the given type.

See *SERIALIZERS*
See SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Function: remove-walker TYPE

Removes the walker function for AST objects of the given type.

See WALKER
See *WALKERS*

Package

glsl-toolkit

Source

walker.lisp (file)

Function: return ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: right-shift ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: root-environment-p ENVIRONMENT

Returns T if the environment is a top-level root environment.

See ENVIRONMENT
See ROOT

Package

glsl-toolkit

Source

walker.lisp (file)

Function: rule NAME

Returns the symbol that identifies the parsing rule of the given name.

This is a place that can be set with the function object
that should be used to parse the rule of the given name.

If no such rule exists, an error is signalled.

Package

glsl-toolkit

Source

parser.lisp (file)

Writer

(setf rule) (function)

Function: (setf rule) PARSER NAME

Package

glsl-toolkit

Source

parser.lisp (file)

Reader

rule (function)

Function: same-+ ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: selection-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: serialize PART &optional TO

Serializes the AST part to shader source.

TO may be one of the following:
- NULL
The output is gathered into a string and returned. - T
The output is sent to *STANDARD-OUTPUT*.
- STREAM
The output is sent to this stream.
- PATHNAME
The output is written to the file. If the file already exists, an error is signalled.

See *SERIALIZE-STREAM*
See SERIALIZE-PART

Package

glsl-toolkit

Source

printer.lisp (file)

Function: serialize-part PART

Serializes the AST part.

This appropriately handles all values that can be contained in the AST. For AST objects, an appropriate serializer function is called if possible. Should an unknown AST object occur, an error is signalled.

See SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Function: serializer TYPE

Accessor to the serializing function for AST objects of the given type.

See *SERIALIZERS*
See DEFINE-SERIALIZER
See REMOVE-SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Writer

(setf serializer) (function)

Function: (setf serializer) FUNCTION TYPE

Package

glsl-toolkit

Source

printer.lisp (file)

Reader

serializer (function)

Function: sformat STRING &rest ARGS

Convenience function used to format to the serializing stream.

A special format directive ~O is provided as well, which causes SERIALIZE-PART to be called on the respective object.

Package

glsl-toolkit

Source

printer.lisp (file)

Function: shader ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: simple-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: statement-p VALUE ENVIRONMENT

Returns T if the given AST node is a statement.

See DECLARATION-P
See EXPRESSION-P
See CONTROL-FLOW-P

Package

glsl-toolkit

Source

walker.lisp (file)

Function: storage-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: struct-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: struct-declarator ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: struct-field-declarator ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: struct-specifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: subroutine-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: subtraction ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: switch-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: token ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: tokenize ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: trace-parse ()

Cause all parse rule functions to emit tracing information.

See UNTRACE-PARSE
See TRACE-PARSE-FUNC

Package

glsl-toolkit

Source

parser.lisp (file)

Function: type-name ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: type-qualifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: type-specifier ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: type-specifier-nonarray ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: unary-expression ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: uniquify TABLE &optional NAME

Create a (hopefully) unique identifier for the given name.

The returned name is prefixed by two underscores. Identifiers like that are reserved for use by the underlying library or framework (us), so there should not be any clash with user identifiers unless the shader is not conforming to begin with.

See *UNIQUE-COUNTER*

Package

glsl-toolkit

Source

merge.lisp (file)

Function: untrace-parse ()

Make all parse rule functions cease to emit tracing information.

See TRACE-PARSE
See UNTRACE-PARSE-FUNC

Package

glsl-toolkit

Source

parser.lisp (file)

Function: variable-declaration ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: variable-identifier-p VALUE ENVIRONMENT

Returns T if the given AST node is an identifier for a variable.

Package

glsl-toolkit

Source

walker.lisp (file)

Function: variable-initializer ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: walk AST FUNCTION &optional ENVIRONMENT

Walk over the AST, calling FUNCTION on each interesting node.

Returns a fresh AST that was constructed by the function.

The function will be called with three arguments:
- The AST node at the current point
- The surrounding context in which the AST node is
- The environment object that maintains lexical information

The function should return a single value, which is the value that should be put into a fresh AST in place of the original node.

Note that calling any of the environment inspection functions on an identifier in a lower level than the current AST node that the function received is not going to work. The lexical information is only guaranteed to be ready by the time the function is called with the identifier itself.

See ROOT-ENVIRONMENT-P
See PREPROCESSOR-P
See CONSTANT-P
See DECLARATION-P
See EXPRESSION-P
See CONTROL-FLOW-P
See KEYWORD-P
See STATEMENT-P
See IDENTIFIER-P
See GLOBAL-IDENTIFIER-P
See LOCAL-IDENTIFIER-P
See VARIABLE-IDENTIFIER-P
See FUNCTION-IDENTIFIER-P
See ENVIRONMENT
See WALK-PART

Package

glsl-toolkit

Source

walker.lisp (file)

Function: walk-part AST CONTEXT FUNCTION ENVIRONMENT

Walk over the given AST node.

On AST objects, this will call out to the respective walker function.

See WALKER

Package

glsl-toolkit

Source

walker.lisp (file)

Function: walker TYPE

Accessor to the walker function for AST objects of the given type.

See *WALKERS*
See REMOVE-WALKER
See DEFINE-WALKER

Package

glsl-toolkit

Source

walker.lisp (file)

Writer

(setf walker) (function)

Function: (setf walker) FUNCTION TYPE

Package

glsl-toolkit

Source

walker.lisp (file)

Reader

walker (function)

Function: while-statement ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: whitespace ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: { ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: | ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: |= ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: || ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

Function: } ()

Package

glsl-parser-rules

Source

grammar.lisp (file)

5.1.6 Classes

Class: environment ()

Struct to hold information about the lexical environment during code walking.

See MAKE-ENVIRONMENT
See ROOT
See BINDINGS

Package

glsl-toolkit

Source

walker.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• bindings (method)
• root (method)

Direct slots

Slot: root

Readers

root (generic function)

Slot: bindings

Initform

(make-hash-table :test (quote equal))

Readers

bindings (generic function)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *indent*

Variable to represent the current indenting level.

See WITH-INDENTATION
See INDENT

Package

glsl-toolkit

Source

printer.lisp (file)

Special Variable: *max-index*

Package

glsl-toolkit

Source

parser.lisp (file)

Special Variable: *serialize-stream*

The stream to which the serializing output is sent to.

This has to be bound when SERIALIZE-PART is called.

Package

glsl-toolkit

Source

printer.lisp (file)

Special Variable: *serializers*

Hash table associating AST object types to serializer functions.

The function must accept a single argument, which is the
AST object itself.

See SERIALIZER
See REMOVE-SERIALIZER

Package

glsl-toolkit

Source

printer.lisp (file)

Special Variable: *sexpr-transforms*

Package

glsl-toolkit

Source

sexpr.lisp (file)

Special Variable: *token-array*

Holds a vector of tokens to be processed by the parser.

See PEEK
See CONSUME
See *TOKEN-INDEX*
See WITH-TOKEN-INPUT

Package

glsl-toolkit

Source

parser.lisp (file)

Special Variable: *token-index*

Holds the index into the token array that represents the current parser position.

See ADVANCE
See BACKTRACK
See *TOKEN-ARRAY*
See WITH-TOKEN-INPUT

Package

glsl-toolkit

Source

parser.lisp (file)

Special Variable: *trace-level*

Integer to represent the current stack level during tracing.

Package

glsl-toolkit

Source

parser.lisp (file)

Special Variable: *traced*

Hash table to hold associate names with the original function definitions.

Package

glsl-toolkit

Source

parser.lisp (file)

Special Variable: *unique-counter*

Counter to hold the current index used to compute names for unique identifiers.

See UNIQUIFY

Package

glsl-toolkit

Source

merge.lisp (file)

Special Variable: *walkers*

Hash table associating AST object types to walker functions.

A walker function must accept three arguments:
- The AST object to process
- The function that should walk over the AST
- The current lexical environment
It must return an AST object to use in place of the current one in the resulting AST.

See WALKER
See REMOVE-WALKER
See DEFINE-WALKER

Package

glsl-toolkit

Source

walker.lisp (file)

5.2.2 Macros

Macro: define-binary-op NAME LEFT OP RIGHT

Shorthand to define a binary operator object.

This takes care to avoid duplicate parsing of the same sequence if the subsequence should succeed. Meaning that if the left expression matches, but the operator or the right one does not it simply returns the left expression, instead of failing to match and causing a re-matching lower down in the tree.

Without this optimisation, performance would suffer greatly.

See DEFINE-OBJECT

Package

glsl-toolkit

Source

grammar.lisp (file)

Macro: define-expr-binary NAME AST DEFAULT

Package

glsl-toolkit

Source

sexpr.lisp (file)

Macro: define-operator-objects &body NAMES

Shorthand to define an object that parses a string and returns the keyword version of that string.

Used to define the various token objects.

See DEFINE-OBJECT

Package

glsl-toolkit

Source

grammar.lisp (file)

Macro: define-sexpr-comparator NAME AST

Package

glsl-toolkit

Source

sexpr.lisp (file)

Macro: define-sexpr-transform OP ARGS &body BODY

Package

glsl-toolkit

Source

sexpr.lisp (file)

Macro: with-glsl-syntax &body FORMS

Package

glsl-toolkit

Source

sexpr.lisp (file)

5.2.3 Functions

Function: %format-object S A CP AT

Helper function to call SERIALIZE-PART in a format string.

Package

glsl-toolkit

Source

printer.lisp (file)

Function: call-traced-function NAME

Wrapper to output trace information around the call to the given function.

See *TRACE-LEVEL*
See *TRACED*

Package

glsl-toolkit

Source

parser.lisp (file)