#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <cctype>
#include <cstring>
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <stack>
#include "cmd-edit.h"
#include "lo-mappers.h"
#include "quit.h"
#include "unistd-wrappers.h"
#include "Cell.h"
#include "comment-list.h"
#include "defun.h"
#include "error.h"
#include "errwarn.h"
#include "input.h"
#include "interpreter.h"
#include "lex.h"
#include "octave.h"
#include "ov.h"
#include "parse.h"
#include "pt-all.h"
#include "symtab.h"
#include "token.h"
#include "utils.h"
#include "variables.h"
#include <oct-parse.h>
#include <oct-gperf.h>

Include dependency graph for lex.cc:

Classes
struct	yy_buffer_state

struct	yy_trans_info

struct	yyguts_t

Namespaces
	octave
	Octave interface to the compression and uncompression libraries.

Macros
#define	BEGIN yyg->yy_start = 1 + 2 *

#define	BLOCK_COMMENT_START 4

#define	CMD_OR_COMPUTED_ASSIGN_OP(PATTERN, TOK)

#define	CMD_OR_OP(PATTERN, TOK, COMPAT)

#define	CMD_OR_UNARY_OP(PATTERN, TOK, COMPAT)

#define	COMMAND_ARG_FINISH

#define	COMMAND_START 1

#define	curr_lexer yyextra

#define	DQ_STRING_START 6

#define	ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)

#define	EOB_ACT_CONTINUE_SCAN 0

#define	EOB_ACT_END_OF_FILE 1

#define	EOB_ACT_LAST_MATCH 2

#define	FLEX_BETA

#define	FLEX_SCANNER

#define	FLEXINT_H

#define	FQ_IDENT_START 8

#define	HANDLE_IDENTIFIER(pattern, get_set)

#define	HANDLE_STRING_CONTINUATION

#define	INITIAL 0

#define	INPUT_FILE_START 3

#define	INT16_MAX (32767)

#define	INT16_MIN (-32767-1)

#define	INT32_MAX (2147483647)

#define	INT32_MIN (-2147483647-1)

#define	INT8_MAX (127)

#define	INT8_MIN (-128)

#define	isatty octave_isatty_wrapper

#define	LINE_COMMENT_START 5

#define	MATRIX_START 2

#define	octave_wrap(yyscanner) (/CONSTCOND/1)

#define	OCTAVE_YYG struct yyguts_t yyg = static_cast<struct yyguts_t> (scanner)

#define	register

#define	REJECT reject_used_but_not_detected

#define	SQ_STRING_START 7

#define	UINT16_MAX (65535U)

#define	UINT32_MAX (4294967295U)

#define	UINT8_MAX (255U)

#define	unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )

#define	YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

#define	YY_BREAK /LINTED/break;

#define	YY_BUF_SIZE 16384

#define	YY_BUFFER_EOF_PENDING 2

#define	YY_BUFFER_NEW 0

#define	YY_BUFFER_NORMAL 1

#define	YY_CURRENT_BUFFER

#define	YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

#define	YY_DECL

#define	YY_DECL_IS_OURS 1

#define	YY_DO_BEFORE_ACTION

#define	YY_END_OF_BUFFER 120

#define	YY_END_OF_BUFFER_CHAR 0

#define	YY_EXIT_FAILURE 2

#define	YY_EXTRA_TYPE octave::base_lexer *

#define	YY_FATAL_ERROR(msg) (octave_get_extra (yyscanner))->fatal_error (msg)

#define	yy_flex_debug yyg->yy_flex_debug_r

#define	YY_FLEX_MAJOR_VERSION 2

#define	YY_FLEX_MINOR_VERSION 6

#define	YY_FLEX_SUBMINOR_VERSION 1

#define	YY_FLUSH_BUFFER octave__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

#define	YY_INPUT(buf, result, max_size) result = curr_lexer->fill_flex_buffer (buf, max_size)

#define	YY_INT_ALIGNED short int

#define	YY_LESS_LINENO(n)

#define	YY_LINENO_REWIND_TO(ptr)

#define	YY_MORE_ADJ 0

#define	yy_new_buffer octave__create_buffer

#define	YY_NEW_FILE octave_restart(yyin ,yyscanner )

#define	YY_NO_UNISTD_H 1

#define	YY_NULL 0

#define	YY_NUM_RULES 119

#define	YY_READ_BUF_SIZE 8192

#define	YY_RESTORE_YY_MORE_OFFSET

#define	YY_RULE_SETUP

#define	YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)

#define	yy_set_bol(at_bol)

#define	yy_set_interactive(is_interactive)

#define	YY_SKIP_YYWRAP

#define	YY_START ((yyg->yy_start - 1) / 2)

#define	YY_START_STACK_INCR 25

#define	YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#define	YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

#define	YY_STRUCT_YY_BUFFER_STATE

#define	YY_TYPEDEF_YY_BUFFER_STATE

#define	YY_TYPEDEF_YY_SCANNER_T

#define	YY_TYPEDEF_YY_SIZE_T

#define	YY_USER_ACTION

#define	yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

#define	yyconst const

#define	yyextra yyg->yyextra_r

#define	yyin yyg->yyin_r

#define	yyleng yyg->yyleng_r

#define	yyless(n)

#define	yyless(n)

#define	yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

#define	yylval yyg->yylval_r

#define	yymore() yymore_used_but_not_detected

#define	yynoreturn

#define	yyout yyg->yyout_r

#define	YYSTATE YY_START

#define	YYSTYPE OCTAVE_STYPE

#define	YYTABLES_NAME "yytables"

#define	yyterminate() return YY_NULL

#define	yytext yyg->yytext_r

#define	yytext_ptr yytext_r

Typedefs
typedef short int	flex_int16_t

typedef int	flex_int32_t

typedef signed char	flex_int8_t

typedef unsigned short int	flex_uint16_t

typedef unsigned int	flex_uint32_t

typedef unsigned char	flex_uint8_t

typedef struct yy_buffer_state *	YY_BUFFER_STATE

typedef unsigned char	YY_CHAR

typedef size_t	yy_size_t

typedef int	yy_state_type

typedef void *	yyscan_t

Functions
static void	display_character (char c)

OCTAVE_EXPORT octave_value_list	F__display_tokens__ (const octave_value_list &args, int nargout) __token_count__

OCTAVE_EXPORT octave_value_list	Fiskeyword (const octave_value_list &args, int) return a list of keywords.eealso

	if (nargin > 1) print_usage()

	if (nargin==0)

static int	input (yyscan_t yyscanner)

bool	octave::is_keyword (const std::string &s)

static bool	looks_like_bin (const char *s, int len)

static bool	looks_like_copyright (const std::string &s)

static bool	looks_like_hex (const char *s, int len)

YY_BUFFER_STATE	octave__create_buffer (FILE *file, int size, yyscan_t yyscanner)
	Allocate and initialize an input buffer state. More...

void	octave__delete_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)
	Destroy the buffer. More...

void	octave__flush_buffer (YY_BUFFER_STATE b, yyscan_t yyscanner)
	Discard all buffered characters. More...

static void	octave__init_buffer (YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner)

static void	octave__load_buffer_state (yyscan_t yyscanner)

YY_BUFFER_STATE	octave__scan_buffer (char *base, yy_size_t size, yyscan_t yyscanner)
	Setup the input buffer state to scan directly from a user-specified character buffer. More...

YY_BUFFER_STATE	octave__scan_bytes (const char *yybytes, int _yybytes_len, yyscan_t yyscanner)
	Setup the input buffer state to scan the given bytes. More...

YY_BUFFER_STATE	octave__scan_string (const char *yystr, yyscan_t yyscanner)
	Setup the input buffer state to scan a string. More...

void	octave__switch_to_buffer (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)
	Switch to a different input buffer. More...

void *	octave_alloc (yy_size_t, yyscan_t yyscanner)

static void	octave_ensure_buffer_stack (yyscan_t yyscanner)

void	octave_free (void *, yyscan_t yyscanner)

int	octave_get_column (yyscan_t yyscanner)
	Get the current column number. More...

int	octave_get_debug (yyscan_t yyscanner)

octave::base_lexer *	octave_get_extra (yyscan_t yyscanner)
	Get the user-defined data for this scanner. More...

FILE *	octave_get_in (yyscan_t yyscanner)
	Get the input stream. More...

int	octave_get_leng (yyscan_t yyscanner)
	Get the length of the current token. More...

int	octave_get_lineno (yyscan_t yyscanner)
	Get the current line number. More...

OCTAVE_STYPE *	octave_get_lval (yyscan_t yyscanner)

FILE *	octave_get_out (yyscan_t yyscanner)
	Get the output stream. More...

char *	octave_get_text (yyscan_t yyscanner)
	Get the current token. More...

int	octave_lex (OCTAVE_STYPE *yylval_param, yyscan_t yyscanner)
	The main scanner function which does all the work. More...

int	octave_lex_destroy (yyscan_t yyscanner)

int	octave_lex_init (yyscan_t *scanner)

int	octave_lex_init_extra (octave::base_lexer user_defined, yyscan_t scanner)

void	octave_pop_buffer_state (yyscan_t yyscanner)
	Removes and deletes the top of the stack, if present. More...

void	octave_push_buffer_state (YY_BUFFER_STATE new_buffer, yyscan_t yyscanner)
	Pushes the new state onto the stack. More...

void *	octave_realloc (void *, yy_size_t, yyscan_t yyscanner)

void	octave_restart (FILE *input_file, yyscan_t yyscanner)
	Immediately switch to a different input stream. More...

void	octave_set_column (int _column_no, yyscan_t yyscanner)
	Set the current column. More...

void	octave_set_debug (int debug_flag, yyscan_t yyscanner)

void	octave_set_extra (octave::base_lexer *user_defined, yyscan_t yyscanner)
	Set the user-defined data. More...

void	octave_set_in (FILE *_in_str, yyscan_t yyscanner)
	Set the input stream. More...

void	octave_set_lineno (int _line_number, yyscan_t yyscanner)
	Set the current line number. More...

void	octave_set_lval (OCTAVE_STYPE *yylval_param, yyscan_t yyscanner)

void	octave_set_out (FILE *_out_str, yyscan_t yyscanner)

static void	yy_fatal_error (const char *msg, yyscan_t yyscanner)

static int	yy_get_next_buffer (yyscan_t yyscanner)

static yy_state_type	yy_get_previous_state (yyscan_t yyscanner)

static int	yy_init_globals (yyscan_t yyscanner)

static yy_state_type	yy_try_NUL_trans (yy_state_type current_state, yyscan_t yyscanner)

static void	yyunput (int c, char *buf_ptr, yyscan_t yyscanner)

Variables
	else

static bool	lexer_debug_flag = false

nd deftypefn *int	nargin = args.length ()

	retval = octave::is_keyword (name)

static bool	Vdisplay_tokens = false

static unsigned int	Vtoken_count = 0

static const flex_int16_t	yy_accept [266]

static const flex_uint16_t	yy_base [299]

static const flex_int16_t	yy_chk [875]

static const flex_int16_t	yy_def [299]

static const YY_CHAR	yy_ec [256]

static const YY_CHAR	yy_meta [55]

static const flex_uint16_t	yy_nxt [875]

Macro Definition Documentation

#define BEGIN yyg->yy_start = 1 + 2 *

Definition at line 151 of file lex.cc.

Referenced by octave::base_lexer::clear_start_state(), and octave::base_lexer::display_start_state().

#define BLOCK_COMMENT_START 4

Definition at line 1030 of file lex.cc.

Referenced by octave_lex().

#define CMD_OR_COMPUTED_ASSIGN_OP	(	PATTERN,
		TOK
	)

Value:

do                                                                   \
     {                                                                  \
       curr_lexer->lexer_debug (PATTERN);                               \
                                                                        \
       if (curr_lexer->previous_token_may_be_command ()                 \
           && curr_lexer->space_follows_previous_token ())              \
         {                                                              \
           yyless (0);                                                  \
           curr_lexer->push_start_state (COMMAND_START);                \
         }                                                              \
       else                                                             \
         {                                                              \
           return curr_lexer->handle_language_extension_op (PATTERN, TOK, \
                                                            false);     \
         }                                                              \
     }                                                                  \
   while (0)

Definition at line 873 of file lex.cc.

Referenced by octave_lex().

#define CMD_OR_OP	(	PATTERN,
		TOK,
		COMPAT
	)

Value:

do                                                                   \
     {                                                                  \
       curr_lexer->lexer_debug (PATTERN);                               \
                                                                        \
       if (curr_lexer->looks_like_command_arg ())                       \
         {                                                              \
           yyless (0);                                                  \
           curr_lexer->push_start_state (COMMAND_START);                \
         }                                                              \
       else                                                             \
         {                                                              \
           return curr_lexer->handle_op_internal (TOK, false, COMPAT);  \
         }                                                              \
     }                                                                  \
   while (0)

Definition at line 856 of file lex.cc.

Referenced by octave_lex().

#define CMD_OR_UNARY_OP	(	PATTERN,
		TOK,
		COMPAT
	)

Definition at line 892 of file lex.cc.

Referenced by octave_lex().

#define COMMAND_ARG_FINISH

Value:

do                                                                   \
     {                                                                  \
       if (curr_lexer->string_text.empty ())                            \
         break;                                                         \
                                                                        \
       int retval = curr_lexer->handle_token (curr_lexer->string_text,  \
                                              SQ_STRING);               \
                                                                        \
       curr_lexer->string_text = "";                                    \
       curr_lexer->command_arg_paren_count = 0;                         \
                                                                        \
       yyless (0);                                                      \
                                                                        \
       return retval;                                                   \
     }                                                                  \
   while (0)

Definition at line 959 of file lex.cc.

Referenced by octave_lex().

#define COMMAND_START 1

Definition at line 1027 of file lex.cc.

Referenced by octave_lex().

#define curr_lexer yyextra

Definition at line 838 of file lex.cc.

Referenced by octave_lex().

#define DQ_STRING_START 6

Definition at line 1032 of file lex.cc.

Referenced by octave_lex().

#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)

Definition at line 1182 of file lex.cc.

Referenced by octave_lex().

#define EOB_ACT_CONTINUE_SCAN 0

Definition at line 195 of file lex.cc.

Referenced by input(), octave_lex(), and yy_get_next_buffer().

#define EOB_ACT_END_OF_FILE 1

Definition at line 196 of file lex.cc.

Referenced by input(), octave_lex(), and yy_get_next_buffer().

#define EOB_ACT_LAST_MATCH 2

Definition at line 197 of file lex.cc.

Referenced by input(), octave_lex(), and yy_get_next_buffer().

#define FLEX_BETA

Definition at line 34 of file lex.cc.

#define FLEX_SCANNER

Definition at line 29 of file lex.cc.

#define FLEXINT_H

Definition at line 50 of file lex.cc.

#define FQ_IDENT_START 8

Definition at line 1034 of file lex.cc.

Referenced by octave_lex().

#define HANDLE_IDENTIFIER	(	pattern,
		get_set
	)

Definition at line 977 of file lex.cc.

Referenced by octave_lex().

#define HANDLE_STRING_CONTINUATION

Value:

do                                                   \
     {                                                  \
       curr_lexer->decrement_promptflag ();             \
       curr_lexer->input_line_number++;                 \
       curr_lexer->current_input_column = 1;            \
                                                        \
       if (curr_lexer->is_push_lexer ())                \
         {                                              \
           if (curr_lexer->at_end_of_buffer ())         \
             return -1;                                 \
                                                        \
           if (curr_lexer->at_end_of_file ())           \
             return curr_lexer->handle_end_of_input (); \
         }                                              \
     }                                                  \
   while (0)

Definition at line 937 of file lex.cc.

Referenced by octave_lex().

#define INITIAL 0

Definition at line 1026 of file lex.cc.

Referenced by octave_lex().

#define INPUT_FILE_START 3

Definition at line 1029 of file lex.cc.

Referenced by octave_lex().

#define INT16_MAX (32767)

Definition at line 92 of file lex.cc.

#define INT16_MIN (-32767-1)

Definition at line 83 of file lex.cc.

#define INT32_MAX (2147483647)

Definition at line 95 of file lex.cc.

#define INT32_MIN (-2147483647-1)

Definition at line 86 of file lex.cc.

#define INT8_MAX (127)

Definition at line 89 of file lex.cc.

#define INT8_MIN (-128)

Definition at line 80 of file lex.cc.

#define isatty octave_isatty_wrapper

Definition at line 829 of file lex.cc.

Referenced by octave__init_buffer().

#define LINE_COMMENT_START 5

Definition at line 1031 of file lex.cc.

Referenced by octave_lex().

#define MATRIX_START 2

Definition at line 1028 of file lex.cc.

Referenced by octave_lex().

#define octave_wrap ( yyscanner ) (/*CONSTCOND*/1)

Definition at line 346 of file lex.cc.

Referenced by input(), and octave_lex().

#define OCTAVE_YYG struct yyguts_t *yyg = static_cast<struct yyguts_t*> (scanner)

Definition at line 4858 of file lex.cc.

Referenced by octave::base_lexer::clear_start_state(), and octave::base_lexer::display_start_state().

#define register

Definition at line 20 of file lex.cc.

#define REJECT reject_used_but_not_detected

Definition at line 731 of file lex.cc.

#define SQ_STRING_START 7

Definition at line 1033 of file lex.cc.

Referenced by octave_lex().

#define UINT16_MAX (65535U)

Definition at line 101 of file lex.cc.

#define UINT32_MAX (4294967295U)

Definition at line 104 of file lex.cc.

#define UINT8_MAX (255U)

Definition at line 98 of file lex.cc.

#define unput ( c ) yyunput( c, yyg->yytext_ptr , yyscanner )

Definition at line 216 of file lex.cc.

Referenced by octave_lex().

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 342 of file lex.cc.

Referenced by octave_lex(), and yy_get_previous_state().

#define YY_BREAK /*LINTED*/break;

Definition at line 1263 of file lex.cc.

Referenced by octave_lex().

#define YY_BUF_SIZE 16384

Definition at line 177 of file lex.cc.

Referenced by octave_lex(), and octave_restart().

#define YY_BUFFER_EOF_PENDING 2

Definition at line 278 of file lex.cc.

Referenced by yy_get_next_buffer().

#define YY_BUFFER_NEW 0

Definition at line 266 of file lex.cc.

Referenced by octave__flush_buffer(), octave__scan_buffer(), and octave_lex().

#define YY_BUFFER_NORMAL 1

Definition at line 267 of file lex.cc.

Referenced by octave_lex().

#define YY_CURRENT_BUFFER

Value:

( yyg->yy_buffer_stack \
                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
                          : NULL)

Definition at line 289 of file lex.cc.

Referenced by octave__delete_buffer(), octave__flush_buffer(), octave__init_buffer(), octave__switch_to_buffer(), octave_get_column(), octave_get_lineno(), octave_lex(), octave_lex_destroy(), octave_pop_buffer_state(), octave_push_buffer_state(), octave_restart(), octave_set_column(), and octave_set_lineno().

#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]

Definition at line 296 of file lex.cc.

Referenced by input(), octave__delete_buffer(), octave__load_buffer_state(), octave__switch_to_buffer(), octave_lex(), octave_lex_destroy(), octave_pop_buffer_state(), octave_push_buffer_state(), octave_restart(), yy_get_next_buffer(), and yyunput().

#define YY_DECL

Value:

int octave_lex \

(YYSTYPE * yylval_param , yyscan_t yyscanner)

octave_lex

int octave_lex(OCTAVE_STYPE *yylval_param, yyscan_t yyscanner)

The main scanner function which does all the work.

Definition: lex.cc:1274

YYSTYPE

#define YYSTYPE

Definition: lex.cc:825

yyscan_t

void * yyscan_t

Definition: oct-tex-lexer.cc:133

Definition at line 1250 of file lex.cc.

#define YY_DECL_IS_OURS 1

Definition at line 1245 of file lex.cc.

#define YY_DO_BEFORE_ACTION

Value:

yyg->yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
  yyg->yy_hold_char = *yy_cp; \
  *yy_cp = '\0'; \
  yyg->yy_c_buf_p = yy_cp;

Definition at line 363 of file lex.cc.

Referenced by octave_lex().

#define YY_END_OF_BUFFER 120

Definition at line 371 of file lex.cc.

Referenced by octave_lex().

#define YY_END_OF_BUFFER_CHAR 0

Definition at line 166 of file lex.cc.

Referenced by input(), octave__flush_buffer(), octave__scan_buffer(), octave__scan_bytes(), and yy_get_next_buffer().

#define YY_EXIT_FAILURE 2

Definition at line 4011 of file lex.cc.

Referenced by yy_fatal_error().

#define YY_EXTRA_TYPE octave::base_lexer *

Definition at line 837 of file lex.cc.

#define YY_FATAL_ERROR ( msg ) (octave_get_extra (yyscanner))->fatal_error (msg)

Definition at line 853 of file lex.cc.

Referenced by octave__create_buffer(), octave__scan_buffer(), octave__scan_bytes(), octave_ensure_buffer_stack(), octave_lex(), octave_set_column(), octave_set_lineno(), yy_get_next_buffer(), and yyunput().

#define yy_flex_debug yyg->yy_flex_debug_r

Definition at line 145 of file lex.cc.

Referenced by octave_get_debug(), and octave_set_debug().

#define YY_FLEX_MAJOR_VERSION 2

Definition at line 30 of file lex.cc.

#define YY_FLEX_MINOR_VERSION 6

Definition at line 31 of file lex.cc.

#define YY_FLEX_SUBMINOR_VERSION 1

Definition at line 32 of file lex.cc.

#define YY_FLUSH_BUFFER octave__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)

Definition at line 310 of file lex.cc.

#define YY_INPUT	(	buf,
		result,
		max_size
	)	result = curr_lexer->fill_flex_buffer (buf, max_size)

Definition at line 845 of file lex.cc.

Referenced by yy_get_next_buffer().

#define YY_INT_ALIGNED short int

Definition at line 25 of file lex.cc.

#define YY_LESS_LINENO ( n )

Definition at line 199 of file lex.cc.

#define YY_LINENO_REWIND_TO ( ptr )

Definition at line 200 of file lex.cc.

#define YY_MORE_ADJ 0

Definition at line 733 of file lex.cc.

Referenced by octave_lex(), yy_get_next_buffer(), and yy_get_previous_state().

#define yy_new_buffer octave__create_buffer

Definition at line 320 of file lex.cc.

#define YY_NEW_FILE octave_restart(yyin ,yyscanner )

Definition at line 164 of file lex.cc.

Referenced by input(), and octave_lex().

#define YY_NO_UNISTD_H 1

Definition at line 828 of file lex.cc.

#define YY_NULL 0

Definition at line 121 of file lex.cc.

Referenced by octave::push_lexer::fill_flex_buffer().

#define YY_NUM_RULES 119

Definition at line 370 of file lex.cc.

#define YY_READ_BUF_SIZE 8192

Definition at line 1173 of file lex.cc.

Referenced by yy_get_next_buffer().

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 734 of file lex.cc.

Referenced by octave_lex().

#define YY_RULE_SETUP

Value:

if ( yyleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
        (yytext[yyleng - 1] == '\n'); \
	YY_USER_ACTION

Definition at line 1266 of file lex.cc.

Referenced by octave_lex().

#define YY_SC_TO_UI ( c ) ((unsigned int) (unsigned char) c)

Definition at line 128 of file lex.cc.

Referenced by octave_lex(), and yy_get_previous_state().

#define yy_set_bol ( at_bol )

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        octave_ensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            octave__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
  } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  }

Definition at line 332 of file lex.cc.

#define yy_set_interactive ( is_interactive )

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        octave_ensure_buffer_stack (yyscanner); \
		YY_CURRENT_BUFFER_LVALUE =    \
            octave__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
  } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  }

Definition at line 322 of file lex.cc.

#define YY_SKIP_YYWRAP

Definition at line 347 of file lex.cc.

#define YY_START ((yyg->yy_start - 1) / 2)

Definition at line 157 of file lex.cc.

Referenced by octave_lex().

#define YY_START_STACK_INCR 25

Definition at line 1231 of file lex.cc.

#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 183 of file lex.cc.

#define YY_STATE_EOF ( state ) (YY_END_OF_BUFFER + state + 1)

Definition at line 161 of file lex.cc.

Referenced by octave_lex().

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 219 of file lex.cc.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 186 of file lex.cc.

#define YY_TYPEDEF_YY_SCANNER_T

Definition at line 132 of file lex.cc.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 191 of file lex.cc.

#define YY_USER_ACTION

Definition at line 1258 of file lex.cc.

#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)

Definition at line 144 of file lex.cc.

Referenced by octave_get_column(), and octave_set_column().

#define yyconst const

Definition at line 112 of file lex.cc.

#define yyextra yyg->yyextra_r

Definition at line 140 of file lex.cc.

Referenced by octave_get_extra(), and octave_set_extra().

#define yyin yyg->yyin_r

Definition at line 138 of file lex.cc.

Referenced by input(), octave__load_buffer_state(), octave_get_in(), octave_lex(), octave_restart(), octave_set_in(), yy_get_next_buffer(), and yy_init_globals().

#define yyleng yyg->yyleng_r

Definition at line 141 of file lex.cc.

Referenced by octave_get_leng(), and octave_lex().

#define yyless ( n )

Value:

do \
    { \
    /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
    *yy_cp = yyg->yy_hold_char; \
    YY_RESTORE_YY_MORE_OFFSET \
    yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    } \
	while ( 0 )

Definition at line 4025 of file lex.cc.

Referenced by octave_lex().

#define yyless ( n )

Value:

do \
    { \
    /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		yytext[yyleng] = yyg->yy_hold_char; \
    yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
    yyg->yy_hold_char = *yyg->yy_c_buf_p; \
    *yyg->yy_c_buf_p = '\0'; \
		yyleng = yyless_macro_arg; \
    } \
	while ( 0 )

Definition at line 4025 of file lex.cc.

#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)

Definition at line 143 of file lex.cc.

Referenced by octave_get_lineno(), and octave_set_lineno().

#define yylval yyg->yylval_r

Definition at line 1088 of file lex.cc.

Referenced by octave_get_lval(), octave_lex(), and octave_set_lval().

#define yymore ( ) yymore_used_but_not_detected

Definition at line 732 of file lex.cc.

#define yynoreturn

Definition at line 117 of file lex.cc.

#define yyout yyg->yyout_r

Definition at line 139 of file lex.cc.

Referenced by octave_get_out(), octave_lex(), octave_set_out(), and yy_init_globals().

#define YYSTATE YY_START

Definition at line 158 of file lex.cc.

#define YYSTYPE OCTAVE_STYPE

Definition at line 825 of file lex.cc.

#define YYTABLES_NAME "yytables"

Definition at line 4351 of file lex.cc.

#define yyterminate ( ) return YY_NULL

Definition at line 1226 of file lex.cc.

#define yytext yyg->yytext_r

Definition at line 142 of file lex.cc.

Referenced by octave_get_text(), and octave_lex().

#define yytext_ptr yytext_r

Definition at line 353 of file lex.cc.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 72 of file lex.cc.

typedef int flex_int32_t

Definition at line 73 of file lex.cc.

typedef signed char flex_int8_t

Definition at line 71 of file lex.cc.

typedef unsigned short int flex_uint16_t

Definition at line 75 of file lex.cc.

typedef unsigned int flex_uint32_t

Definition at line 76 of file lex.cc.

typedef unsigned char flex_uint8_t

Definition at line 74 of file lex.cc.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 187 of file lex.cc.

typedef unsigned char YY_CHAR

Definition at line 349 of file lex.cc.

typedef size_t yy_size_t

Definition at line 192 of file lex.cc.

typedef int yy_state_type

Definition at line 351 of file lex.cc.

typedef void* yyscan_t

Definition at line 133 of file lex.cc.

Function Documentation

static void display_character ( char c )

static

Definition at line 4381 of file lex.cc.

References c.

Referenced by octave::base_lexer::looking_at_space(), and octave::base_lexer::xunput().

OCTAVE_EXPORT octave_value_list F__display_tokens__	(	const octave_value_list &	args,
		int	nargout
	)

Referenced by install_lex_fcns().

OCTAVE_EXPORT octave_value_list Fiskeyword	(	const octave_value_list &	args,
		int
	)

Definition at line 4554 of file lex.cc.

References retval.

Referenced by install_lex_fcns().

if	(	nargin	,
		1
	)

Referenced by yyunput().

if ( nargin = = 0 )

Definition at line 4563 of file lex.cc.

References error(), octave_kw::name, string_vector::resize(), string_vector::sort(), string, TOTAL_KEYWORDS, and wordlist.

static int input ( yyscan_t yyscanner )

static

Definition at line 3579 of file lex.cc.

References c, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, octave_restart(), octave_wrap, yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, yy_get_next_buffer(), yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, YY_NEW_FILE, and yyin.

static bool looks_like_bin	(	const char *	s,
		int	len
	)

inlinestatic

Definition at line 5297 of file lex.cc.

static bool looks_like_copyright ( const std::string & s )

static

Definition at line 4775 of file lex.cc.

References octave::lexical_feedback::token_cache::front(), token::is_symbol(), octave::lexical_feedback::pending_local_variables, token::symbol_name(), and octave::lexical_feedback::tokens.

Referenced by octave::base_lexer::handle_close_bracket().

static bool looks_like_hex	(	const char *	s,
		int	len
	)

inlinestatic

Definition at line 5303 of file lex.cc.

YY_BUFFER_STATE octave__create_buffer	(	FILE *	file,
		int	size,
		yyscan_t	yyscanner
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use `YY_BUF_SIZE`.
yyscanner	The scanner object.

Returns: the allocated buffer state.

Definition at line 3722 of file lex.cc.

References b, octave__init_buffer(), octave_alloc(), yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

Referenced by octave_lex(), and octave_restart().

void octave__delete_buffer	(	YY_BUFFER_STATE	b,
		yyscan_t	yyscanner
	)

Destroy the buffer.

Parameters

b	a buffer created with octave__create_buffer()
yyscanner	The scanner object.

Definition at line 3750 of file lex.cc.

References octave_free(), yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_is_our_buffer.

Referenced by octave_lex_destroy(), and octave_pop_buffer_state().

void octave__flush_buffer	(	YY_BUFFER_STATE	b,
		yyscan_t	yyscanner
	)

Discard all buffered characters.

On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually `YY_CURRENT_BUFFER`.
yyscanner	The scanner object.

Definition at line 3799 of file lex.cc.

References octave__load_buffer_state(), yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yy_buffer_state::yy_n_chars.

Referenced by octave__init_buffer().

static void octave__init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file,
		yyscan_t	yyscanner
	)

static

Definition at line 3770 of file lex.cc.

References file, isatty, octave__flush_buffer(), yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

Referenced by octave__create_buffer(), and octave_restart().

static void octave__load_buffer_state ( yyscan_t yyscanner )

static

Definition at line 3707 of file lex.cc.

References yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_hold_char, yyguts_t::yy_n_chars, and yyin.

Referenced by octave__flush_buffer(), octave__switch_to_buffer(), octave_lex(), octave_pop_buffer_state(), octave_push_buffer_state(), and octave_restart().

YY_BUFFER_STATE octave__scan_buffer	(	char *	base,
		yy_size_t	size,
		yyscan_t	yyscanner
	)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters

base	the character buffer
size	the size in bytes of the character buffer
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Definition at line 3930 of file lex.cc.

References b, octave__switch_to_buffer(), octave_alloc(), yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, yy_buffer_state::yy_buf_size, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, yy_buffer_state::yy_is_interactive, yy_buffer_state::yy_is_our_buffer, and yy_buffer_state::yy_n_chars.

Referenced by octave__scan_bytes().

YY_BUFFER_STATE octave__scan_bytes	(	const char *	yybytes,
		int	_yybytes_len,
		yyscan_t	yyscanner
	)

Setup the input buffer state to scan the given bytes.

The next call to octave_lex() will scan from a copy of bytes.

Parameters

yybytes	the byte buffer to scan
_yybytes_len	the number of bytes in the buffer pointed to by bytes.
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Definition at line 3980 of file lex.cc.

References b, octave__scan_buffer(), octave_alloc(), YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

Referenced by octave__scan_string().

YY_BUFFER_STATE octave__scan_string	(	const char *	yystr,
		yyscan_t	yyscanner
	)

Setup the input buffer state to scan a string.

The next call to octave_lex() will scan from a copy of str.

Parameters

yystr	a NUL-terminated string to scan
yyscanner	The scanner object.

Returns: the newly allocated buffer state object.

Note: If you want to scan bytes that may contain NUL values, then use octave__scan_bytes() instead.

Definition at line 3967 of file lex.cc.

References octave__scan_bytes(), and strlen().

void octave__switch_to_buffer	(	YY_BUFFER_STATE	new_buffer,
		yyscan_t	yyscanner
	)

Switch to a different input buffer.

Parameters

new_buffer	The new input buffer.
yyscanner	The scanner object.

Definition at line 3675 of file lex.cc.

References octave__load_buffer_state(), octave_ensure_buffer_stack(), yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, yyguts_t::yy_hold_char, and yyguts_t::yy_n_chars.

Referenced by octave__scan_buffer().

void * octave_alloc	(	yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 4363 of file lex.cc.

References malloc().

Referenced by octave__create_buffer(), octave__scan_buffer(), octave__scan_bytes(), octave_ensure_buffer_stack(), octave_lex_init(), and octave_lex_init_extra().

static void octave_ensure_buffer_stack ( yyscan_t yyscanner )

static

Definition at line 3880 of file lex.cc.

References octave_alloc(), octave_realloc(), yyguts_t::yy_buffer_stack, yyguts_t::yy_buffer_stack_max, yyguts_t::yy_buffer_stack_top, and YY_FATAL_ERROR.

Referenced by octave__switch_to_buffer(), octave_lex(), octave_push_buffer_state(), and octave_restart().

void octave_free	(	void *	ptr,
		yyscan_t	yyscanner
	)

Definition at line 4375 of file lex.cc.

References free().

Referenced by octave__delete_buffer(), and octave_lex_destroy().

int octave_get_column ( yyscan_t yyscanner )

Get the current column number.

Parameters

yyscanner The scanner object.

Definition at line 4066 of file lex.cc.

References YY_CURRENT_BUFFER, and yycolumn.

int octave_get_debug ( yyscan_t yyscanner )

Definition at line 4171 of file lex.cc.

References yy_flex_debug.

octave::base_lexer * octave_get_extra ( yyscan_t yyscanner )

Get the user-defined data for this scanner.

Parameters

yyscanner The scanner object.

Definition at line 4044 of file lex.cc.

References yyextra.

FILE * octave_get_in ( yyscan_t yyscanner )

Get the input stream.

Parameters

yyscanner The scanner object.

Definition at line 4079 of file lex.cc.

References yyin.

int octave_get_leng ( yyscan_t yyscanner )

Get the length of the current token.

Parameters

yyscanner The scanner object.

Definition at line 4097 of file lex.cc.

References yyleng.

int octave_get_lineno ( yyscan_t yyscanner )

Get the current line number.

Parameters

yyscanner The scanner object.

Definition at line 4053 of file lex.cc.

References YY_CURRENT_BUFFER, and yylineno.

OCTAVE_STYPE * octave_get_lval ( yyscan_t yyscanner )

Definition at line 4185 of file lex.cc.

References yylval.

FILE * octave_get_out ( yyscan_t yyscanner )

Get the output stream.

Parameters

yyscanner The scanner object.

Definition at line 4088 of file lex.cc.

References yyout.

char * octave_get_text ( yyscan_t yyscanner )

Get the current token.

Parameters

yyscanner The scanner object.

Definition at line 4107 of file lex.cc.

References yytext.

int octave_lex	(	OCTAVE_STYPE *	yylval_param,
		yyscan_t	yyscanner
	)

The main scanner function which does all the work.

Definition at line 1274 of file lex.cc.

References ADD_EQ, AND_EQ, octave_comment_elt::block, BLOCK_COMMENT_START, c, CMD_OR_COMPUTED_ASSIGN_OP, CMD_OR_OP, CMD_OR_UNARY_OP, COMMAND_ARG_FINISH, COMMAND_START, curr_lexer, DIV_EQ, DQ_STRING, DQ_STRING_START, ECHO, EDIV, EDIV_EQ, ELEFTDIV, ELEFTDIV_EQ, EMINUS, EMUL, EMUL_EQ, octave_comment_elt::end_of_line, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, EPLUS, EPOW, EPOW_EQ, EXPR_AND, EXPR_AND_AND, EXPR_EQ, EXPR_GE, EXPR_GT, EXPR_LE, EXPR_LT, EXPR_NE, EXPR_NOT, EXPR_OR, EXPR_OR_OR, FQ_IDENT_START, octave_comment_elt::full_line, HANDLE_IDENTIFIER, HANDLE_STRING_CONTINUATION, HERMITIAN, IMAG_NUM, INITIAL, INPUT_FILE, INPUT_FILE_START, LEFTDIV, LEFTDIV_EQ, LEXICAL_ERROR, LINE_COMMENT_START, MATRIX_START, MINUS_MINUS, MUL_EQ, nm, NUM, octave__create_buffer(), octave__load_buffer_state(), octave_ensure_buffer_stack(), octave_wrap, OR_EQ, PLUS_PLUS, POW, POW_EQ, result, SQ_STRING, SQ_STRING_START, string, SUB_EQ, TRANSPOSE, undo_string_escape(), unput, warning_with_id(), yy_accept, YY_AT_BOL, yy_base, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yyguts_t::yy_c_buf_p, yy_chk, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_def, yyguts_t::yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, yy_ec, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yyguts_t::yy_hold_char, yyguts_t::yy_init, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yyguts_t::yy_n_chars, YY_NEW_FILE, yy_nxt, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, yyguts_t::yy_start, YY_STATE_EOF, yy_try_NUL_trans(), yyin, yyleng, yyless, yylval, yyout, and yytext.

Referenced by octave::push_parser::run().

int octave_lex_destroy ( yyscan_t yyscanner )

Definition at line 4295 of file lex.cc.

References octave__delete_buffer(), octave_free(), octave_pop_buffer_state(), yyguts_t::yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_globals(), and yyguts_t::yy_start_stack.

int octave_lex_init ( yyscan_t * scanner )

Definition at line 4204 of file lex.cc.

References octave_alloc(), and yy_init_globals().

Referenced by octave::base_lexer::reset().

int octave_lex_init_extra	(	octave::base_lexer *	user_defined,
		yyscan_t *	scanner
	)

Definition at line 4233 of file lex.cc.

References octave_alloc(), octave_set_extra(), and yy_init_globals().

void octave_pop_buffer_state ( yyscan_t yyscanner )

Removes and deletes the top of the stack, if present.

The next element becomes the new top.

Parameters

yyscanner The scanner object.

Definition at line 3860 of file lex.cc.

References octave__delete_buffer(), octave__load_buffer_state(), yyguts_t::yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yyguts_t::yy_did_buffer_switch_on_eof.

Referenced by octave_lex_destroy().

void octave_push_buffer_state	(	YY_BUFFER_STATE	new_buffer,
		yyscan_t	yyscanner
	)

Pushes the new state onto the stack.

The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer	The new state.
yyscanner	The scanner object.

Definition at line 3829 of file lex.cc.

References octave__load_buffer_state(), octave_ensure_buffer_stack(), yyguts_t::yy_buffer_stack_top, yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yyguts_t::yy_did_buffer_switch_on_eof, yyguts_t::yy_hold_char, and yyguts_t::yy_n_chars.

void * octave_realloc	(	void *	ptr,
		yy_size_t	size,
		yyscan_t	yyscanner
	)

Definition at line 4369 of file lex.cc.

Referenced by octave_ensure_buffer_stack(), and yy_get_next_buffer().

void octave_restart	(	FILE *	input_file,
		yyscan_t	yyscanner
	)

Immediately switch to a different input stream.

Parameters

input_file	A readable stream.
yyscanner	The scanner object.

Note: This function does not reset the start condition to INITIAL .

Definition at line 3657 of file lex.cc.

References octave__create_buffer(), octave__init_buffer(), octave__load_buffer_state(), octave_ensure_buffer_stack(), YY_BUF_SIZE, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yyin.

Referenced by input(), and yy_get_next_buffer().

void octave_set_column	(	int	_column_no,
		yyscan_t	yyscanner
	)

Set the current column.

Parameters

_column_no	column number
yyscanner	The scanner object.

Definition at line 4142 of file lex.cc.

References YY_CURRENT_BUFFER, YY_FATAL_ERROR, and yycolumn.

void octave_set_debug	(	int	debug_flag,
		yyscan_t	yyscanner
	)

Definition at line 4177 of file lex.cc.

References yy_flex_debug.

void octave_set_extra	(	octave::base_lexer *	user_defined,
		yyscan_t	yyscanner
	)

Set the user-defined data.

This data is never touched by the scanner.

Parameters

user_defined	The data to be associated with this scanner.
yyscanner	The scanner object.

Definition at line 4117 of file lex.cc.

References yyextra.

Referenced by octave_lex_init_extra(), and octave::base_lexer::reset().

void octave_set_in	(	FILE *	_in_str,
		yyscan_t	yyscanner
	)

Set the input stream.

This does not discard the current input buffer.

Parameters

_in_str	A readable stream.
yyscanner	The scanner object.

See also: octave__switch_to_buffer

Definition at line 4159 of file lex.cc.

References yyin.

void octave_set_lineno	(	int	_line_number,
		yyscan_t	yyscanner
	)

Set the current line number.

Parameters

_line_number	line number
yyscanner	The scanner object.

Definition at line 4127 of file lex.cc.

References YY_CURRENT_BUFFER, YY_FATAL_ERROR, and yylineno.

void octave_set_lval	(	OCTAVE_STYPE *	yylval_param,
		yyscan_t	yyscanner
	)

Definition at line 4191 of file lex.cc.

References yylval.

void octave_set_out	(	FILE *	_out_str,
		yyscan_t	yyscanner
	)

Definition at line 4165 of file lex.cc.

References yyout.

static void yy_fatal_error	(	const char *	msg,
		yyscan_t	yyscanner
	)

static

Definition at line 4014 of file lex.cc.

References YY_EXIT_FAILURE.

static int yy_get_next_buffer ( yyscan_t yyscanner )

static

Definition at line 3339 of file lex.cc.

References b, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, octave_realloc(), octave_restart(), yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yyguts_t::yy_c_buf_p, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yyguts_t::yy_n_chars, YY_READ_BUF_SIZE, and yyin.

Referenced by input(), and octave_lex().

static yy_state_type yy_get_previous_state ( yyscan_t yyscanner )

static

Definition at line 3474 of file lex.cc.

References yy_accept, YY_AT_BOL, yy_base, yyguts_t::yy_c_buf_p, yy_chk, yy_def, yy_ec, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yy_nxt, YY_SC_TO_UI, and yyguts_t::yy_start.

Referenced by octave_lex().

static int yy_init_globals ( yyscan_t yyscanner )

static

Definition at line 4261 of file lex.cc.

References yyguts_t::yy_buffer_stack, yyguts_t::yy_buffer_stack_max, yyguts_t::yy_buffer_stack_top, yyguts_t::yy_c_buf_p, yyguts_t::yy_init, yyguts_t::yy_start, yyguts_t::yy_start_stack, yyguts_t::yy_start_stack_depth, yyguts_t::yy_start_stack_ptr, yyin, and yyout.

Referenced by octave_lex_destroy(), octave_lex_init(), and octave_lex_init_extra().

static yy_state_type yy_try_NUL_trans	(	yy_state_type	current_state,
		yyscan_t	yyscanner
	)

static

Definition at line 3508 of file lex.cc.

References yy_accept, yy_base, yyguts_t::yy_c_buf_p, yy_chk, yy_def, yyguts_t::yy_last_accepting_cpos, yyguts_t::yy_last_accepting_state, yy_meta, and yy_nxt.

Referenced by octave_lex().

static void yyunput	(	int	c,
		char *	buf_ptr,
		yyscan_t	yyscanner
	)

static

Definition at line 3535 of file lex.cc.

References if(), yyguts_t::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yyguts_t::yy_hold_char, and yyguts_t::yy_n_chars.

Variable Documentation

else

Initial value:

{

std::string name = args(0).xstring_value ("iskeyword: NAME must be a string")

args

JNIEnv void * args

Definition: ov-java.cc:67

name

OCTAVE_EXPORT octave_value_list any number nd example oindent prints the prompt xample Pick a any number!nd example oindent and waits for the user to enter a value The string entered by the user is evaluated as an so it may be a literal a variable name

Definition: input.cc:871

string

If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string

Definition: utils.cc:854

Definition at line 4585 of file lex.cc.

bool lexer_debug_flag = false

static

Definition at line 1022 of file lex.cc.

nd deftypefn* int nargin = args.length ()

Definition at line 4558 of file lex.cc.

return retval = octave::is_keyword (name)

Definition at line 4587 of file lex.cc.

Referenced by Fiskeyword(), and octave::lexical_feedback::init().

bool Vdisplay_tokens = false

static

Definition at line 1017 of file lex.cc.

unsigned int Vtoken_count = 0

static

Definition at line 1019 of file lex.cc.

const flex_int16_t yy_accept[266]

static

Definition at line 379 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

const flex_uint16_t yy_base[299]

static

Definition at line 454 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

const flex_int16_t yy_chk[875]

static

Definition at line 628 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

const flex_int16_t yy_def[299]

static

Definition at line 491 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

const YY_CHAR yy_ec[256]

static

Definition at line 412 of file lex.cc.

Referenced by octave_lex(), and yy_get_previous_state().

const YY_CHAR yy_meta[55]

static

Initial value:

=
    {   0,
        1,    2,    3,    3,    1,    4,    2,    5,    1,    6,
        2,    2,    1,    1,    2,    1,    7,    1,    8,    8,
        8,    8,    1,    2,    1,    1,    1,    1,    9,   10,
       10,   10,   11,    5,    2,   12,    2,    1,   11,   10,
       10,   10,   10,    5,    5,    5,    5,    5,    5,    5,
        2,    1,    2,    1
    }

Definition at line 444 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

const flex_uint16_t yy_nxt[875]

static

Definition at line 528 of file lex.cc.

Referenced by octave_lex(), yy_get_previous_state(), and yy_try_NUL_trans().

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation