Page tree

Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Published by Scroll Versions from space RWDEVEL and version 10.4.3

...

StartLine

Get linenode type of 'Line' represents start line that includes given textnode. From this linenode it is possible to get information about numerical value of start line but also about other properties. See Linenode Properties.

EndLine

Get linenode type of 'Line' represents end line that includes given textnode. From this Line node it is possible to get information about numerical value of end line but also about other properties. See Linenode Properties.

Filename

Name of the file that contains the node.

LastInBody

Checks Boolean property. Returns true if the textnode is last in the body.

LastInLine

Checks Boolean property. Returns true if the textnode is last in the line.

LastInLineIgnoringWhiteSpace

Checks Boolean property. Returns true if the textnode is last in the line. Spaces and tabs are ignored.

LastInLineIgnoringWhiteSpaceAndComments

Checks Boolean property. Returns true if the textnode is last in the line. Spaces, tabs, and comments are ignored.

Next

Get next textnode(s). There are two options for this property:

The Next Direct Check option gets next textnode. For example:

Table of Content Zone
maxLevel3
minLevel3
locationtop

Name

Represents name of textnode. Usually this is the direct node name, but sometimes for special nodes the value of name is different. Special nodes include #define and #include. For example:

Code Block
statement if  Name is string "if"
#define MAX_VAL 512 Name is string "MAX_VAL"
#define SUM(A,B)(A+B) Name is string "SUM"
#include <stdio.h> Name is string "<stdio.h>"

Value - '#define' textnode only

Represents value for special textnode #define. For example:

Code Block
#define MAX_VAL 512  Value is string "512"
#define SUM(A,B)(A+B) Value is string "(A+B)"

Parameters - '#define' textnode only

Get textnode(s) type of 'Identifier Constant'. Represents parameters in macro. For example:

Code Block
#define SUM(A,B)(A+B) Parameters are textnodes: "A" and "B"

StartColumn

Represents numerical value of start column for given textnode. For example:

Code Block
if(true) For statement if StartColumn
numerical value is 1
if(true) For statement if StartColumn 
numerical value is 6
\_ sixth column
\_ first column

EndColumn

Represents numerical value of end column for given textnode. For example:

Code Block
if(true) For statement if EndColumn numerical 
value is 2
if(true) For statement if EndColumn 
numerical value is 7.
\_ seventh column
\_ second column
Anchor
StartLineStartLine
Code Block
int myValue = 5;

The Next InDirect Check option gets a collection of the same repeated textnodes up to the different node. For example:

Code Block
int myValue    = 5;

Next(InDirect) from myValue is a collection of four textnodes Space.

IsMacro

Returns true if the Token or Identifier Constant is a macro. For example:

Code Block
void FOO(int x);
void bar(int x) {
   #define FOO(x) x++;
   FOO(x);     /* IsMacro = true for token 'FOO' */
   #undef FOO
   FOO(x);     /* IsMacro = false for token 'FOO' */
}

NextIgnoringWSAndCommentsAndBackslash

Get next textnode(s). Comments, spaces, tabs and backslashes that precede new lines (line continuation characters) are ignored. There are two options.

The NextIgnoringWSAndCommentsAndBackslash Direct Check option gets next nextnodes. For example:

Code Block
int myValue /* description for variable */ \
  = 5;
 

NextIgnoringWSAndCommentsAndBackslash(Direct) from myValue is the first textnode = (Assignment operator).

The NextIgnoringWSAndCommentsAndBackslash InDirect Check option gets a collection of all textnodes up to the end of the body. For example:

Code Block
void foo() {
    int myValue = \
       5;
    //some text explaining usage of value myChar, for example
    int myChar = 'd';
};

NextIgnoringWSAndCommentsAndBackslash(InDirect) from myValue is a collection of eight textnodes of different types: =,5,;,int,myChar,=,'d',;

NextIgnoringWhitespace

Get next textnode(s). Spaces and tabs are ignored. There are two options.

The NextIgnoringWhitespace Direct Check option gets next textnodes. For example:

Code Block
int myValue = 5;

NextIgnoringWhitespace(Direct) from myValue is the first textnode 'Assignment operator'.

The NextIgnoringWhitespace InDirect Check gets a collection of all textnodes up to end of body. For example:

Code Block
void foo() {
    int myValue = 5;
    int myChar = 'd';
};

Next(InDirect) from myValue is collection of eight textnodes of different types: =,5,;,int,myChar,=,'d',;

NextIgnoringWhitespaceAndComments

Get next textnode(s). Comments, spaces, and tabs are ignored. There are two options.

The NextIgnoringWhitespaceAndComments Direct Check optiongets the next textnode. For example:

Code Block
int myValue /* description for variable */ = 5;

NextIgnoringWhitespaceAndComments(Direct) from myValue is the first textnode = (Assignment operator).

The NextIgnoringWhitespaceAndComments InDirect Check option gets collection of all textnodes up to end of body. For example:

Code Block
void foo() {
    int myValue = 5;
    //some text explaining usage of value myChar, for example
    int myChar = 'd';
};

Next(InDirect) from myValue is collection of eight textnodes of different types: =,5,;,int,myChar,=,'d',;

Previous

Get previous textnode(s). There are two options.

The Previous Direct Check option gets previous textnode. For example:

Code Block
int myValue = 5; 

Previous(Direct) from myValue is the first textnode space.

The Previous InDirect Check option gets a collection of all textnodes up to the beginning of the body. For example:

Code Block
int myValue    = 5;

Previous(InDirect) from myValue is a space and int.

PreviousIgnoringWhitespace

Get previous textnode(s). Spaces and tabs are ignored. There are two options.

The PreviousIgnoringWhitespace Direct Check option gets previous textnode. For example:

Code Block
int myValue = 5;

PreviousIgnoringWhitespace(Direct) from myValue is the first textnode int.

The PreviousIgnoringWhitespace InDirect Check option gets collection of all textnodes up to beginning of body. For example:

Code Block
void foo() {
    int myValue = 5;
    int myChar = 'd';
};

Previous(InDirect) from myChar is a collection of six textnodes of different types: int,;,5,=,myValue,int

PreviousIgnoringWhitespaceAndComments

Get previous textnode(s). Comments, spaces, and tabs are ignored. There are two options.
The PreviousIgnoringWhitespaceAndComments Direct Check option gets previous textnode. For example:

Code Block
int /* comment */ myValue = 5;

PreviousIgnoringWhitespaceAndComments(Direct) from myValue is first textnode int

The PreviousIgnoringWhitespaceAndComments InDirect Check option gets a collection of all textnodes up to end of body. For example:

Code Block
void foo() {
    int myValue = 5;
    //some text explaining usage of value myChar, for example
    int myChar = 'd';
};

Previous(InDirect) from myChar is collection of eight textnodes of different types: int,;,5.=,myValue,int

BackwardLastOf

Searches for elements within searching chain from right to left. Use to find a specific element and ignore some others.

ForwardLastOf

Searches for elements within searching chain from left to right. Use to find a specific element and ignore some others.

Body

The Body property is the opposite of Context property.

The {, [, (, #define and #pragma textnodes have bodies consisting of additional textnode(s).

For the {, [ and ( textnodes:

  • Body beginning: first textnode after {, [, (.
  • Body ending: last textnode before }, ], or ).

For the #define and #pragma textnodes:

  • Body beginning: first textnode after #define/#pragma (usually space).
  • Body ending: last textnode in the #define/#pragma (usually last textnode in line).

There are two options for the body property.

The Body Direct Check option gets the first textnode in the body. For example:

Code Block
void foo() {
    int g;
}

Body Direct from { is the first textnode in the body type of space. For example:

#define MAX_VAL 512 //"MAX VAL"

Body Direct from #define is the first textnode in the body type of space.

The Body InDirect Check option gets a collection of all textnodes inside body. For example:

Code Block
void foo() {
    int g;
}

Body InDirect from { is a collection of eight textnodes of different types: four spaces, int,’Space’,g,; . For example:

#define MAX_VAL 512 //"MAX VAL"

Body InDirect from #define is collection of six textnodes of different types: space, MAX_VAL,’Space’,512,’Space’,//"MAX VAL".

Context

The Context property is the opposite of the Body property.

The following textnodes inside the body belong to root textnodes: {, [, (, #define and #pragma.

There are two options available for the context property:

The Context Direct Check option gets first textnode in context. For example:

Code Block
void foo(int val) {
 int tabs[10];
}

Context Direct from 'Number Constant' is the [ textnode.

The Context InDirect Check option gets a collection of contexts textnodes. For example:

Code Block
void foo(int val) {
 int tabs[10];
}


Context (InDirect) from 'Number Constant' are the [ and { textnodes.

...