/[svn]/linuxsampler/trunk/src/scriptvm/common.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/scriptvm/common.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2871 by schoenebeck, Sun Apr 10 18:22:23 2016 UTC revision 3292 by schoenebeck, Sat Jun 24 13:43:09 2017 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014-2016 Christian Schoenebeck   * Copyright (c) 2014-2017 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 9  Line 9 
9    
10  // This header defines data types shared between the VM core implementation  // This header defines data types shared between the VM core implementation
11  // (inside the current source directory) and other parts of the sampler  // (inside the current source directory) and other parts of the sampler
12  // (located at other source directories).  // (located at other source directories). It also acts as public API of the
13    // Real-Time script engine for other applications.
14    
15  #ifndef LS_INSTR_SCRIPT_PARSER_COMMON_H  #ifndef LS_INSTR_SCRIPT_PARSER_COMMON_H
16  #define LS_INSTR_SCRIPT_PARSER_COMMON_H  #define LS_INSTR_SCRIPT_PARSER_COMMON_H
# Line 76  namespace LinuxSampler { Line 77  namespace LinuxSampler {
77          VM_EXEC_ERROR = (1<<2), ///< A runtime error occurred while executing the script (i.e. a call to some built-in script function failed).          VM_EXEC_ERROR = (1<<2), ///< A runtime error occurred while executing the script (i.e. a call to some built-in script function failed).
78      };      };
79    
80        /** @brief Script event handler type.
81         *
82         * Identifies one of the possible event handler callback types defined by
83         * the NKSP script language.
84         */
85        enum VMEventHandlerType_t {
86            VM_EVENT_HANDLER_INIT, ///< Initilization event handler, that is script's "on init ... end on" code block.
87            VM_EVENT_HANDLER_NOTE, ///< Note event handler, that is script's "on note ... end on" code block.
88            VM_EVENT_HANDLER_RELEASE, ///< Release event handler, that is script's "on release ... end on" code block.
89            VM_EVENT_HANDLER_CONTROLLER, ///< Controller event handler, that is script's "on controller ... end on" code block.
90        };
91    
92      // just symbol prototyping      // just symbol prototyping
93      class VMIntExpr;      class VMIntExpr;
94      class VMStringExpr;      class VMStringExpr;
# Line 145  namespace LinuxSampler { Line 158  namespace LinuxSampler {
158           * expressions to an array expression for you, instead this method will           * expressions to an array expression for you, instead this method will
159           * simply return NULL!           * simply return NULL!
160           *           *
161             * @b Note: this method is currently, and in contrast to its other
162             * counter parts, declared as virtual method. Some deriving classes are
163             * currently using this to override this default implementation in order
164             * to implement an "evaluate now as integer array" behavior. This has
165             * efficiency reasons, however this also currently makes this part of
166             * the API less clean and should thus be addressed in future with
167             * appropriate changes to the API.
168             *
169           * @see exprType()           * @see exprType()
170           */           */
171          VMIntArrayExpr* asIntArray() const;          virtual VMIntArrayExpr* asIntArray() const;
172    
173            /**
174             * Returns true in case this expression can be considered to be a
175             * constant expression. A constant expression will retain the same
176             * value throughout the entire life time of a script and the
177             * expression's constant value may be evaluated already at script
178             * parse time, which may result in performance benefits during script
179             * runtime.
180             *
181             * @b NOTE: A constant expression is per se always also non modifyable.
182             * But a non modifyable expression may not necessarily be a constant
183             * expression!
184             *
185             * @see isModifyable()
186             */
187            virtual bool isConstExpr() const = 0;
188    
189            /**
190             * Returns true in case this expression is allowed to be modified.
191             * If this method returns @c false then this expression must be handled
192             * as read-only expression, which means that assigning a new value to it
193             * is either not possible or not allowed.
194             *
195             * @b NOTE: A constant expression is per se always also non modifyable.
196             * But a non modifyable expression may not necessarily be a constant
197             * expression!
198             *
199             * @see isConstExpr()
200             */
201            bool isModifyable() const;
202      };      };
203    
204      /** @brief Virtual machine integer expression      /** @brief Virtual machine integer expression
# Line 354  namespace LinuxSampler { Line 405  namespace LinuxSampler {
405          virtual ExprType_t argType(int iArg) const = 0;          virtual ExprType_t argType(int iArg) const = 0;
406    
407          /**          /**
408           * This function is called by the parser to check whether arguments           * This method is called by the parser to check whether arguments
409           * passed in scripts to this function are accepted by this function. If           * passed in scripts to this function are accepted by this function. If
410           * a script calls this function with an argument's data type not           * a script calls this function with an argument's data type not
411           * accepted by this function, the parser will throw a parser error. On           * accepted by this function, the parser will throw a parser error. On
# Line 372  namespace LinuxSampler { Line 423  namespace LinuxSampler {
423          virtual bool acceptsArgType(int iArg, ExprType_t type) const = 0;          virtual bool acceptsArgType(int iArg, ExprType_t type) const = 0;
424    
425          /**          /**
426             * This method is called by the parser to check whether some arguments
427             * (and if yes which ones) passed to this script function will be
428             * modified by this script function. Most script functions simply use
429             * their arguments as inputs, that is they only read the argument's
430             * values. However some script function may also use passed
431             * argument(s) as output variables. In this case the function
432             * implementation must return @c true for the respective argument
433             * index here.
434             *
435             * @param iArg - index of the function argument in question
436             *               (must be between 0 .. maxAllowedArgs() - 1)
437             */
438            virtual bool modifiesArg(int iArg) const = 0;
439    
440            /**
441           * Implements the actual function execution. This exec() method is           * Implements the actual function execution. This exec() method is
442           * called by the VM whenever this function implementation shall be           * called by the VM whenever this function implementation shall be
443           * executed at script runtime. This method blocks until the function           * executed at script runtime. This method blocks until the function
# Line 411  namespace LinuxSampler { Line 477  namespace LinuxSampler {
477      struct VMRelPtr {      struct VMRelPtr {
478          void** base; ///< Base pointer.          void** base; ///< Base pointer.
479          int offset;  ///< Offset (in bytes) relative to base pointer.          int offset;  ///< Offset (in bytes) relative to base pointer.
480            bool readonly; ///< Whether the pointed data may be modified or just be read.
481      };      };
482    
483      /** @brief Pointer to built-in VM integer variable (of C/C++ type int).      /** @brief Pointer to built-in VM integer variable (of C/C++ type int).
# Line 438  namespace LinuxSampler { Line 505  namespace LinuxSampler {
505          VMIntRelPtr() {          VMIntRelPtr() {
506              base   = NULL;              base   = NULL;
507              offset = 0;              offset = 0;
508                readonly = false;
509          }          }
510          VMIntRelPtr(const VMRelPtr& data) {          VMIntRelPtr(const VMRelPtr& data) {
511              base   = data.base;              base   = data.base;
512              offset = data.offset;              offset = data.offset;
513                readonly = false;
514          }          }
515          virtual int evalInt() { return *(int*)&(*(uint8_t**)base)[offset]; }          virtual int evalInt() { return *(int*)&(*(uint8_t**)base)[offset]; }
516          virtual void assign(int i) { *(int*)&(*(uint8_t**)base)[offset] = i; }          virtual void assign(int i) { *(int*)&(*(uint8_t**)base)[offset] = i; }
# Line 479  namespace LinuxSampler { Line 548  namespace LinuxSampler {
548          }          }
549      };      };
550    
551        #if HAVE_CXX_EMBEDDED_PRAGMA_DIAGNOSTICS
552        # define COMPILER_DISABLE_OFFSETOF_WARNING                    \
553            _Pragma("GCC diagnostic push")                            \
554            _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"")
555        # define COMPILER_RESTORE_OFFSETOF_WARNING \
556            _Pragma("GCC diagnostic pop")
557        #else
558        # define COMPILER_DISABLE_OFFSETOF_WARNING
559        # define COMPILER_RESTORE_OFFSETOF_WARNING
560        #endif
561    
562      /**      /**
563       * Convenience macro for initializing VMIntRelPtr and VMInt8RelPtr       * Convenience macro for initializing VMIntRelPtr and VMInt8RelPtr
564       * structures. Usage example:       * structures. Usage example:
# Line 521  namespace LinuxSampler { Line 601  namespace LinuxSampler {
601       * complexity inside the sampler engines which provide the actual script       * complexity inside the sampler engines which provide the actual script
602       * functionalities.       * functionalities.
603       */       */
604      #define DECLARE_VMINT(basePtr, T_struct, T_member) ( \      #define DECLARE_VMINT(basePtr, T_struct, T_member) (          \
605          (VMRelPtr) {                                     \          /* Disable offsetof warning, trust us, we are cautios. */ \
606              (void**) &basePtr,                           \          COMPILER_DISABLE_OFFSETOF_WARNING                         \
607              offsetof(T_struct, T_member)                 \          (VMRelPtr) {                                              \
608          }                                                \              (void**) &basePtr,                                    \
609      )                                                    \              offsetof(T_struct, T_member),                         \
610                false                                                 \
611            }                                                         \
612            COMPILER_RESTORE_OFFSETOF_WARNING                         \
613        )                                                             \
614    
615        /**
616         * Same as DECLARE_VMINT(), but this one defines the VMIntRelPtr and
617         * VMInt8RelPtr structures to be of read-only type. That means the script
618         * parser will abort any script at parser time if the script is trying to
619         * modify such a read-only built-in variable.
620         *
621         * @b NOTE: this is only intended for built-in read-only variables that
622         * may change during runtime! If your built-in variable's data is rather
623         * already available at parser time and won't change during runtime, then
624         * you should rather register a built-in constant in your VM class instead!
625         *
626         * @see ScriptVM::builtInConstIntVariables()
627         */
628        #define DECLARE_VMINT_READONLY(basePtr, T_struct, T_member) ( \
629            /* Disable offsetof warning, trust us, we are cautios. */ \
630            COMPILER_DISABLE_OFFSETOF_WARNING                         \
631            (VMRelPtr) {                                              \
632                (void**) &basePtr,                                    \
633                offsetof(T_struct, T_member),                         \
634                true                                                  \
635            }                                                         \
636            COMPILER_RESTORE_OFFSETOF_WARNING                         \
637        )                                                             \
638    
639      /** @brief Built-in VM 8 bit integer array variable.      /** @brief Built-in VM 8 bit integer array variable.
640       *       *
# Line 537  namespace LinuxSampler { Line 645  namespace LinuxSampler {
645      struct VMInt8Array {      struct VMInt8Array {
646          int8_t* data;          int8_t* data;
647          int size;          int size;
648            bool readonly; ///< Whether the array data may be modified or just be read.
649    
650            VMInt8Array() : data(NULL), size(0), readonly(false) {}
651        };
652    
653          VMInt8Array() : data(NULL), size(0) {}      /** @brief Virtual machine script variable.
654         *
655         * Common interface for all variables accessed in scripts.
656         */
657        class VMVariable : virtual public VMExpr {
658        public:
659            /**
660             * Whether a script may modify the content of this variable by
661             * assigning a new value to it.
662             *
663             * @see isConstExpr(), assign()
664             */
665            virtual bool isAssignable() const = 0;
666    
667            /**
668             * In case this variable is assignable, this method will be called to
669             * perform the value assignment to this variable with @a expr
670             * reflecting the new value to be assigned.
671             *
672             * @param expr - new value to be assigned to this variable
673             */
674            virtual void assignExpr(VMExpr* expr) = 0;
675        };
676        
677        /** @brief Dynamically executed variable (abstract base class).
678         *
679         * Interface for the implementation of a dynamically generated content of
680         * a built-in script variable. Most built-in variables are simply pointers
681         * to some native location in memory. So when a script reads them, the
682         * memory location is simply read to get the value of the variable. A
683         * dynamic variable however is not simply a memory location. For each access
684         * to a dynamic variable some native code is executed to actually generate
685         * and provide the content (value) of this type of variable.
686         */
687        class VMDynVar : public VMVariable {
688        public:
689            /**
690             * Returns true in case this dynamic variable can be considered to be a
691             * constant expression. A constant expression will retain the same value
692             * throughout the entire life time of a script and the expression's
693             * constant value may be evaluated already at script parse time, which
694             * may result in performance benefits during script runtime.
695             *
696             * However due to the "dynamic" behavior of dynamic variables, almost
697             * all dynamic variables are probably not constant expressions. That's
698             * why this method returns @c false by default. If you are really sure
699             * that your dynamic variable implementation can be considered a
700             * constant expression then you may override this method and return
701             * @c true instead. Note that when you return @c true here, your
702             * dynamic variable will really just be executed once; and exectly
703             * already when the script is loaded!
704             *
705             * As an example you may implement a "constant" built-in dynamic
706             * variable that checks for a certain operating system feature and
707             * returns the result of that OS feature check as content (value) of
708             * this dynamic variable. Since the respective OS feature might become
709             * available/unavailable after OS updates, software migration, etc. the
710             * OS feature check should at least be performed once each time the
711             * application is launched. And since the OS feature check might take a
712             * certain amount of execution time, it might make sense to only
713             * perform the check if the respective variable name is actually
714             * referenced at all in the script to be loaded. Note that the dynamic
715             * variable will still be evaluated again though if the script is
716             * loaded again. So it is up to you to probably cache the result in the
717             * implementation of your dynamic variable.
718             *
719             * On doubt, please rather consider to use a constant built-in script
720             * variable instead of implementing a "constant" dynamic variable, due
721             * to the runtime overhead a dynamic variable may cause.
722             *
723             * @see isAssignable()
724             */
725            bool isConstExpr() const OVERRIDE { return false; }
726    
727            /**
728             * In case this dynamic variable is assignable, the new value (content)
729             * to be assigned to this dynamic variable.
730             *
731             * By default this method does nothing. Override and implement this
732             * method in your subclass in case your dynamic variable allows to
733             * assign a new value by script.
734             *
735             * @param expr - new value to be assigned to this variable
736             */
737            void assignExpr(VMExpr* expr) OVERRIDE {}
738    
739            virtual ~VMDynVar() {}
740        };
741    
742        /** @brief Dynamically executed variable (of integer data type).
743         *
744         * This is the base class for all built-in integer script variables whose
745         * variable content needs to be provided dynamically by executable native
746         * code on each script variable access.
747         */
748        class VMDynIntVar : virtual public VMDynVar, virtual public VMIntExpr {
749        public:
750        };
751    
752        /** @brief Dynamically executed variable (of string data type).
753         *
754         * This is the base class for all built-in string script variables whose
755         * variable content needs to be provided dynamically by executable native
756         * code on each script variable access.
757         */
758        class VMDynStringVar : virtual public VMDynVar, virtual public VMStringExpr {
759        public:
760        };
761    
762        /** @brief Dynamically executed variable (of integer array data type).
763         *
764         * This is the base class for all built-in integer array script variables
765         * whose variable content needs to be provided dynamically by executable
766         * native code on each script variable access.
767         */
768        class VMDynIntArrayVar : virtual public VMDynVar, virtual public VMIntArrayExpr {
769        public:
770      };      };
771    
772      /** @brief Provider for built-in script functions and variables.      /** @brief Provider for built-in script functions and variables.
# Line 575  namespace LinuxSampler { Line 803  namespace LinuxSampler {
803           * variables, which never change their value at runtime.           * variables, which never change their value at runtime.
804           */           */
805          virtual std::map<String,int> builtInConstIntVariables() = 0;          virtual std::map<String,int> builtInConstIntVariables() = 0;
806    
807            /**
808             * Returns a variable name indexed map of all built-in dynamic variables,
809             * which are not simply data stores, rather each one of them executes
810             * natively to provide or alter the respective script variable data.
811             */
812            virtual std::map<String,VMDynVar*> builtInDynamicVariables() = 0;
813      };      };
814    
815      /** @brief Execution state of a virtual machine.      /** @brief Execution state of a virtual machine.
# Line 617  namespace LinuxSampler { Line 852  namespace LinuxSampler {
852           * @see ScriptVM::exec()           * @see ScriptVM::exec()
853           */           */
854          virtual int suspensionTimeMicroseconds() const = 0;          virtual int suspensionTimeMicroseconds() const = 0;
855    
856            /**
857             * Causes all polyphonic variables to be reset to zero values. A
858             * polyphonic variable is expected to be zero when entering a new event
859             * handler instance. As an exception the values of polyphonic variables
860             * shall only be preserved from an note event handler instance to its
861             * correspending specific release handler instance. So in the latter
862             * case the script author may pass custom data from the note handler to
863             * the release handler, but only for the same specific note!
864             */
865            virtual void resetPolyphonicData() = 0;
866    
867            /**
868             * Returns amount of virtual machine instructions which have been
869             * performed the last time when this execution context was executing a
870             * script. So in case you need the overall amount of instructions
871             * instead, then you need to add them by yourself after each
872             * ScriptVM::exec() call.
873             */
874            virtual size_t instructionsPerformed() const = 0;
875    
876            /**
877             * Sends a signal to this script execution instance to abort its script
878             * execution as soon as possible. This method is called i.e. when one
879             * script execution instance intends to stop another script execution
880             * instance.
881             */
882            virtual void signalAbort() = 0;
883      };      };
884    
885      /** @brief Script callback for a certain event.      /** @brief Script callback for a certain event.
# Line 627  namespace LinuxSampler { Line 890  namespace LinuxSampler {
890      class VMEventHandler {      class VMEventHandler {
891      public:      public:
892          /**          /**
893             * Type of this event handler, which identifies its purpose. For example
894             * for a "on note ... end on" script callback block,
895             * @c VM_EVENT_HANDLER_NOTE would be returned here.
896             */
897            virtual VMEventHandlerType_t eventHandlerType() const = 0;
898    
899            /**
900           * Name of the event handler which identifies its purpose. For example           * Name of the event handler which identifies its purpose. For example
901           * for a "on note ... end on" script callback block, the name "note"           * for a "on note ... end on" script callback block, the name "note"
902           * would be returned here.           * would be returned here.
# Line 641  namespace LinuxSampler { Line 911  namespace LinuxSampler {
911      };      };
912    
913      /**      /**
914         * Reflects the precise position and span of a specific code block within
915         * a script. This is currently only used for the locations of commented
916         * code blocks due to preprocessor statements, and for parser errors and
917         * parser warnings.
918         *
919         * @see ParserIssue for code locations of parser errors and parser warnings
920         *
921         * @see VMParserContext::preprocessorComments() for locations of code which
922         *      have been filtered out by preprocessor statements
923         */
924        struct CodeBlock {
925            int firstLine; ///< The first line number of this code block within the script (indexed with 1 being the very first line).
926            int lastLine; ///< The last line number of this code block within the script.
927            int firstColumn; ///< The first column of this code block within the script (indexed with 1 being the very first column).
928            int lastColumn; ///< The last column of this code block within the script.
929        };
930    
931        /**
932       * Encapsulates a noteworty parser issue. This encompasses the type of the       * Encapsulates a noteworty parser issue. This encompasses the type of the
933       * issue (either a parser error or parser warning), a human readable       * issue (either a parser error or parser warning), a human readable
934       * explanation text of the error or warning and the location of the       * explanation text of the error or warning and the location of the
935       * encountered parser issue within the script.       * encountered parser issue within the script.
936         *
937         * @see VMSourceToken for processing syntax highlighting instead.
938       */       */
939      struct ParserIssue {      struct ParserIssue : CodeBlock {
940          String txt; ///< Human readable explanation text of the parser issue.          String txt; ///< Human readable explanation text of the parser issue.
         int line; ///< Line number within the script where this issue was encountered.  
941          ParserIssueType_t type; ///< Whether this issue is either a parser error or just a parser warning.          ParserIssueType_t type; ///< Whether this issue is either a parser error or just a parser warning.
942    
943          /**          /**
# Line 657  namespace LinuxSampler { Line 946  namespace LinuxSampler {
946          inline void dump() {          inline void dump() {
947              switch (type) {              switch (type) {
948                  case PARSER_ERROR:                  case PARSER_ERROR:
949                      printf("[ERROR] line %d: %s\n", line, txt.c_str());                      printf("[ERROR] line %d, column %d: %s\n", firstLine, firstColumn, txt.c_str());
950                      break;                      break;
951                  case PARSER_WARNING:                  case PARSER_WARNING:
952                      printf("[Warning] line %d: %s\n", line, txt.c_str());                      printf("[Warning] line %d, column %d: %s\n", firstLine, firstColumn, txt.c_str());
953                      break;                      break;
954              }              }
955          }          }
# Line 728  namespace LinuxSampler { Line 1017  namespace LinuxSampler {
1017          virtual std::vector<ParserIssue> warnings() const = 0;          virtual std::vector<ParserIssue> warnings() const = 0;
1018    
1019          /**          /**
1020             * Returns all code blocks of the script which were filtered out by the
1021             * preprocessor.
1022             */
1023            virtual std::vector<CodeBlock> preprocessorComments() const = 0;
1024    
1025            /**
1026           * Returns the translated virtual machine representation of an event           * Returns the translated virtual machine representation of an event
1027           * handler block (i.e. "on note ... end on" code block) within the           * handler block (i.e. "on note ... end on" code block) within the
1028           * parsed script. This translated representation of the event handler           * parsed script. This translated representation of the event handler
# Line 748  namespace LinuxSampler { Line 1043  namespace LinuxSampler {
1043          virtual VMEventHandler* eventHandlerByName(const String& name) = 0;          virtual VMEventHandler* eventHandlerByName(const String& name) = 0;
1044      };      };
1045    
1046        class SourceToken;
1047    
1048        /** @brief Recognized token of a script's source code.
1049         *
1050         * Represents one recognized token of a script's source code, for example
1051         * a keyword, variable name, etc. and it provides further informations about
1052         * that particular token, i.e. the precise location (line and column) of the
1053         * token within the original script's source code.
1054         *
1055         * This class is not actually used by the sampler itself. It is rather
1056         * provided for external script editor applications. Primary purpose of
1057         * this class is syntax highlighting for external script editors.
1058         *
1059         * @see ParserIssue for processing compile errors and warnings instead.
1060         */
1061        class VMSourceToken {
1062        public:
1063            VMSourceToken();
1064            VMSourceToken(SourceToken* ct);
1065            VMSourceToken(const VMSourceToken& other);
1066            virtual ~VMSourceToken();
1067    
1068            // original text of this token as it is in the script's source code
1069            String text() const;
1070    
1071            // position of token in script
1072            int firstLine() const; ///< First line this source token is located at in script source code (indexed with 0 being the very first line). Most source code tokens are not spanning over multiple lines, the only current exception are comments, in the latter case you need to process text() to get the last line and last column for the comment.
1073            int firstColumn() const; ///< First column on the first line this source token is located at in script source code (indexed with 0 being the very first column). To get the length of this token use text().length().
1074    
1075            // base types
1076            bool isEOF() const; ///< Returns true in case this source token represents the end of the source code file.
1077            bool isNewLine() const; ///< Returns true in case this source token represents a line feed character (i.e. "\n" on Unix systems).
1078            bool isKeyword() const; ///< Returns true in case this source token represents a language keyword (i.e. "while", "function", "declare", "on", etc.).
1079            bool isVariableName() const; ///< Returns true in case this source token represents a variable name (i.e. "$someIntVariable", "%someArrayVariable", "\@someStringVariable"). @see isIntegerVariable(), isStringVariable(), isArrayVariable() for the precise variable type.
1080            bool isIdentifier() const; ///< Returns true in case this source token represents an identifier, which currently always means a function name.
1081            bool isNumberLiteral() const; ///< Returns true in case this source token represents a number literal (i.e. 123).
1082            bool isStringLiteral() const; ///< Returns true in case this source token represents a string literal (i.e. "Some text").
1083            bool isComment() const; ///< Returns true in case this source token represents a source code comment.
1084            bool isPreprocessor() const; ///< Returns true in case this source token represents a preprocessor statement.
1085            bool isOther() const; ///< Returns true in case this source token represents anything else not covered by the token types mentioned above.
1086    
1087            // extended types
1088            bool isIntegerVariable() const; ///< Returns true in case this source token represents an integer variable name (i.e. "$someIntVariable").
1089            bool isStringVariable() const; ///< Returns true in case this source token represents an string variable name (i.e. "\@someStringVariable").
1090            bool isArrayVariable() const; ///< Returns true in case this source token represents an array variable name (i.e. "%someArryVariable").
1091            bool isEventHandlerName() const; ///< Returns true in case this source token represents an event handler name (i.e. "note", "release", "controller").
1092    
1093            VMSourceToken& operator=(const VMSourceToken& other);
1094    
1095        private:
1096            SourceToken* m_token;
1097        };
1098    
1099  } // namespace LinuxSampler  } // namespace LinuxSampler
1100    
1101  #endif // LS_INSTR_SCRIPT_PARSER_COMMON_H  #endif // LS_INSTR_SCRIPT_PARSER_COMMON_H
Legend:
Removed from v.2871  
changed lines
  Added in v.3292
  ViewVC Help
Powered by ViewVC