⬅️ Back to Table of Contents
📄 AST.js
📊 Analysis Summary
| Metric |
Count |
| 🔧 Functions |
5 |
| 🧱 Classes |
28 |
| 📦 Imports |
1 |
| 📊 Variables & Constants |
1 |
📚 Table of Contents
🛠️ File Location:
📂 examples/jsm/transpiler/AST.js
📦 Imports
| Name |
Source |
toFloatType |
./TranspilerUtils.js |
Variables & Constants
| Name |
Type |
Kind |
Value |
Exported |
array |
this[Extract<keyof this, string>] & a... |
let/var |
this[ key ] |
✗ |
Functions
ASTNode.getType(): any
Returns: any
Code
getType() {
return this.type || null;
}
ASTNode.getParent(parents: any[]): any
Parameters:
Returns: any
Calls:
parents.pushthis.parent.getParent
Code
getParent( parents = [] ) {
if ( this.parent === null ) {
return parents;
}
parents.push( this.parent );
return this.parent.getParent( parents );
}
ASTNode.initialize(): void
Returns: void
Calls:
Code
initialize() {
for ( const key in this ) {
if ( this[ key ] && this[ key ].isASTNode ) {
this[ key ].parent = this;
} else if ( Array.isArray( this[ key ] ) ) {
const array = this[ key ];
for ( const item of array ) {
if ( item && item.isASTNode ) {
item.parent = this;
}
}
}
}
}
Operator.getType(): any
Returns: any
Calls:
this.left.getTypethis.right.getTypetoFloatType (from ./TranspilerUtils.js)
Code
getType() {
const leftType = this.left.getType();
const rightType = this.right.getType();
if ( leftType === rightType ) {
return leftType;
} else if ( toFloatType( leftType ) === toFloatType( rightType ) ) {
return toFloatType( leftType );
}
return null;
}
Accessor.getType(): any
Returns: any
Calls:
this.linker.reference.getTypesuper.getType
Code
getType() {
if ( this.linker.reference ) {
return this.linker.reference.getType();
}
return super.getType();
}
Classes
ASTNode
Class Code
export class ASTNode {
constructor() {
this.isASTNode = true;
this.linker = {
reference: null,
accesses: [],
assignments: []
};
this.parent = null;
}
get isNumericExpression() {
return false;
}
get hasAssignment() {
if ( this.isAssignment === true ) {
return true;
}
if ( this.parent === null ) {
return false;
}
return this.parent.hasAssignment;
}
getType() {
return this.type || null;
}
getParent( parents = [] ) {
if ( this.parent === null ) {
return parents;
}
parents.push( this.parent );
return this.parent.getParent( parents );
}
initialize() {
for ( const key in this ) {
if ( this[ key ] && this[ key ].isASTNode ) {
this[ key ].parent = this;
} else if ( Array.isArray( this[ key ] ) ) {
const array = this[ key ];
for ( const item of array ) {
if ( item && item.isASTNode ) {
item.parent = this;
}
}
}
}
}
}
Methods
getType(): any
Code
getType() {
return this.type || null;
}
getParent(parents: any[]): any
Code
getParent( parents = [] ) {
if ( this.parent === null ) {
return parents;
}
parents.push( this.parent );
return this.parent.getParent( parents );
}
initialize(): void
Code
initialize() {
for ( const key in this ) {
if ( this[ key ] && this[ key ].isASTNode ) {
this[ key ].parent = this;
} else if ( Array.isArray( this[ key ] ) ) {
const array = this[ key ];
for ( const item of array ) {
if ( item && item.isASTNode ) {
item.parent = this;
}
}
}
}
}
Class Code
export class Comment extends ASTNode {
constructor( comment ) {
super();
this.comment = comment;
this.isComment = true;
this.initialize();
}
}
Program
Class Code
export class Program extends ASTNode {
constructor( body = [] ) {
super();
this.body = body;
this.isProgram = true;
this.initialize();
}
}
VariableDeclaration
Class Code
export class VariableDeclaration extends ASTNode {
constructor( type, name, value = null, next = null, immutable = false ) {
super();
this.type = type;
this.name = name;
this.value = value;
this.next = next;
this.immutable = immutable;
this.isVariableDeclaration = true;
this.initialize();
}
get isAssignment() {
return this.value !== null;
}
}
Class Code
export class Uniform extends ASTNode {
constructor( type, name ) {
super();
this.type = type;
this.name = name;
this.isUniform = true;
this.initialize();
}
}
Varying
Class Code
export class Varying extends ASTNode {
constructor( type, name ) {
super();
this.type = type;
this.name = name;
this.isVarying = true;
this.initialize();
}
}
FunctionParameter
Class Code
export class FunctionParameter extends ASTNode {
constructor( type, name, qualifier = null, immutable = true ) {
super();
this.type = type;
this.name = name;
this.qualifier = qualifier;
this.immutable = immutable;
this.isFunctionParameter = true;
this.initialize();
}
}
FunctionDeclaration
Class Code
export class FunctionDeclaration extends ASTNode {
constructor( type, name, params = [], body = [] ) {
super();
this.type = type;
this.name = name;
this.params = params;
this.body = body;
this.isFunctionDeclaration = true;
this.initialize();
}
}
Expression
Class Code
export class Expression extends ASTNode {
constructor( expression ) {
super();
this.expression = expression;
this.isExpression = true;
this.initialize();
}
}
Ternary
Class Code
export class Ternary extends ASTNode {
constructor( cond, left, right ) {
super();
this.cond = cond;
this.left = left;
this.right = right;
this.isTernary = true;
this.initialize();
}
}
Operator
Class Code
export class Operator extends ASTNode {
constructor( type, left, right ) {
super();
this.type = type;
this.left = left;
this.right = right;
this.isOperator = true;
this.initialize();
}
get isAssignment() {
return /^(=|\+=|-=|\*=|\/=|%=|<<=|>>=|>>>=|&=|\^=|\|=)$/.test( this.type );
}
get isNumericExpression() {
if ( this.left.isNumericExpression && this.right.isNumericExpression ) {
return true;
}
return false;
}
getType() {
const leftType = this.left.getType();
const rightType = this.right.getType();
if ( leftType === rightType ) {
return leftType;
} else if ( toFloatType( leftType ) === toFloatType( rightType ) ) {
return toFloatType( leftType );
}
return null;
}
}
Methods
getType(): any
Code
getType() {
const leftType = this.left.getType();
const rightType = this.right.getType();
if ( leftType === rightType ) {
return leftType;
} else if ( toFloatType( leftType ) === toFloatType( rightType ) ) {
return toFloatType( leftType );
}
return null;
}
Unary
Class Code
export class Unary extends ASTNode {
constructor( type, expression, after = false ) {
super();
this.type = type;
this.expression = expression;
this.after = after;
this.isUnary = true;
this.initialize();
}
get isAssignment() {
return /^(\+\+|--)$/.test( this.type );
}
get isNumericExpression() {
if ( this.expression.isNumber ) {
return true;
}
return false;
}
}
Number
Class Code
export class Number extends ASTNode {
constructor( value, type = 'float' ) {
super();
this.type = type;
this.value = value;
this.isNumber = true;
this.initialize();
}
get isNumericExpression() {
return true;
}
}
String
Class Code
export class String extends ASTNode {
constructor( value ) {
super();
this.value = value;
this.isString = true;
this.initialize();
}
}
Conditional
Class Code
export class Conditional extends ASTNode {
constructor( cond = null, body = [] ) {
super();
this.cond = cond;
this.body = body;
this.elseConditional = null;
this.isConditional = true;
this.initialize();
}
}
FunctionCall
Class Code
export class FunctionCall extends ASTNode {
constructor( name, params = [] ) {
super();
this.name = name;
this.params = params;
this.isFunctionCall = true;
this.initialize();
}
}
Return
Class Code
export class Return extends ASTNode {
constructor( value ) {
super();
this.value = value;
this.isReturn = true;
this.initialize();
}
}
Discard
Class Code
export class Discard extends ASTNode {
constructor() {
super();
this.isDiscard = true;
this.initialize();
}
}
Continue
Class Code
export class Continue extends ASTNode {
constructor() {
super();
this.isContinue = true;
this.initialize();
}
}
Break
Class Code
export class Break extends ASTNode {
constructor() {
super();
this.isBreak = true;
this.initialize();
}
}
Accessor
Class Code
export class Accessor extends ASTNode {
constructor( property ) {
super();
this.property = property;
this.isAccessor = true;
this.initialize();
}
getType() {
if ( this.linker.reference ) {
return this.linker.reference.getType();
}
return super.getType();
}
}
Methods
getType(): any
Code
getType() {
if ( this.linker.reference ) {
return this.linker.reference.getType();
}
return super.getType();
}
StaticElement
Class Code
export class StaticElement extends ASTNode {
constructor( value ) {
super();
this.value = value;
this.isStaticElement = true;
this.initialize();
}
}
DynamicElement
Class Code
export class DynamicElement extends ASTNode {
constructor( value ) {
super();
this.value = value;
this.isDynamicElement = true;
this.initialize();
}
}
AccessorElements
Class Code
export class AccessorElements extends ASTNode {
constructor( object, elements = [] ) {
super();
this.object = object;
this.elements = elements;
this.isAccessorElements = true;
this.initialize();
}
}
For
Class Code
export class For extends ASTNode {
constructor( initialization, condition, afterthought, body = [] ) {
super();
this.initialization = initialization;
this.condition = condition;
this.afterthought = afterthought;
this.body = body;
this.isFor = true;
this.initialize();
}
}
While
Class Code
export class While extends ASTNode {
constructor( condition, body = [] ) {
super();
this.condition = condition;
this.body = body;
this.isWhile = true;
this.initialize();
}
}
Switch
Class Code
export class Switch extends ASTNode {
constructor( discriminant, cases ) {
super();
this.discriminant = discriminant;
this.cases = cases;
this.isSwitch = true;
this.initialize();
}
}
SwitchCase
Class Code
export class SwitchCase extends ASTNode {
constructor( body, conditions = null ) {
super();
this.body = body;
this.conditions = conditions;
this.isDefault = conditions === null ? true : false;
this.isSwitchCase = true;
this.initialize();
}
}