/[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 2942 by schoenebeck, Wed Jul 13 15:51:06 2016 UTC revision 3056 by schoenebeck, Fri Dec 16 12:57:59 2016 UTC
# Line 157  namespace LinuxSampler { Line 157  namespace LinuxSampler {
157           * expressions to an array expression for you, instead this method will           * expressions to an array expression for you, instead this method will
158           * simply return NULL!           * simply return NULL!
159           *           *
160             * @b Note: this method is currently, and in contrast to its other
161             * counter parts, declared as virtual method. Some deriving classes are
162             * currently using this to override this default implementation in order
163             * to implement an "evaluate now as integer array" behavior. This has
164             * efficiency reasons, however this also currently makes this part of
165             * the API less clean and should thus be addressed in future with
166             * appropriate changes to the API.
167             *
168           * @see exprType()           * @see exprType()
169           */           */
170          VMIntArrayExpr* asIntArray() const;          virtual VMIntArrayExpr* asIntArray() const;
171    
172            /**
173             * Returns true in case this expression can be considered to be a
174             * constant expression. A constant expression will retain the same
175             * value throughout the entire life time of a script and the
176             * expression's constant value may be evaluated already at script
177             * parse time, which may result in performance benefits during script
178             * runtime.
179             *
180             * @b NOTE: A constant expression is per se always also non modifyable.
181             * But a non modifyable expression may not necessarily be a constant
182             * expression!
183             *
184             * @see isModifyable()
185             */
186            virtual bool isConstExpr() const = 0;
187    
188            /**
189             * Returns true in case this expression is allowed to be modified.
190             * If this method returns @c false then this expression must be handled
191             * as read-only expression, which means that assigning a new value to it
192             * is either not possible or not allowed.
193             *
194             * @b NOTE: A constant expression is per se always also non modifyable.
195             * But a non modifyable expression may not necessarily be a constant
196             * expression!
197             *
198             * @see isConstExpr()
199             */
200            bool isModifyable() const;
201      };      };
202    
203      /** @brief Virtual machine integer expression      /** @brief Virtual machine integer expression
# Line 366  namespace LinuxSampler { Line 404  namespace LinuxSampler {
404          virtual ExprType_t argType(int iArg) const = 0;          virtual ExprType_t argType(int iArg) const = 0;
405    
406          /**          /**
407           * This function is called by the parser to check whether arguments           * This method is called by the parser to check whether arguments
408           * passed in scripts to this function are accepted by this function. If           * passed in scripts to this function are accepted by this function. If
409           * a script calls this function with an argument's data type not           * a script calls this function with an argument's data type not
410           * 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 384  namespace LinuxSampler { Line 422  namespace LinuxSampler {
422          virtual bool acceptsArgType(int iArg, ExprType_t type) const = 0;          virtual bool acceptsArgType(int iArg, ExprType_t type) const = 0;
423    
424          /**          /**
425             * This method is called by the parser to check whether some arguments
426             * (and if yes which ones) passed to this script function will be
427             * modified by this script function. Most script functions simply use
428             * their arguments as inputs, that is they only read the argument's
429             * values. However some script function may also use passed
430             * argument(s) as output variables. In this case the function
431             * implementation must return @c true for the respective argument
432             * index here.
433             *
434             * @param iArg - index of the function argument in question
435             *               (must be between 0 .. maxAllowedArgs() - 1)
436             */
437            virtual bool modifiesArg(int iArg) const = 0;
438    
439            /**
440           * Implements the actual function execution. This exec() method is           * Implements the actual function execution. This exec() method is
441           * called by the VM whenever this function implementation shall be           * called by the VM whenever this function implementation shall be
442           * executed at script runtime. This method blocks until the function           * executed at script runtime. This method blocks until the function
# Line 423  namespace LinuxSampler { Line 476  namespace LinuxSampler {
476      struct VMRelPtr {      struct VMRelPtr {
477          void** base; ///< Base pointer.          void** base; ///< Base pointer.
478          int offset;  ///< Offset (in bytes) relative to base pointer.          int offset;  ///< Offset (in bytes) relative to base pointer.
479            bool readonly; ///< Whether the pointed data may be modified or just be read.
480      };      };
481    
482      /** @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 450  namespace LinuxSampler { Line 504  namespace LinuxSampler {
504          VMIntRelPtr() {          VMIntRelPtr() {
505              base   = NULL;              base   = NULL;
506              offset = 0;              offset = 0;
507                readonly = false;
508          }          }
509          VMIntRelPtr(const VMRelPtr& data) {          VMIntRelPtr(const VMRelPtr& data) {
510              base   = data.base;              base   = data.base;
511              offset = data.offset;              offset = data.offset;
512                readonly = false;
513          }          }
514          virtual int evalInt() { return *(int*)&(*(uint8_t**)base)[offset]; }          virtual int evalInt() { return *(int*)&(*(uint8_t**)base)[offset]; }
515          virtual void assign(int i) { *(int*)&(*(uint8_t**)base)[offset] = i; }          virtual void assign(int i) { *(int*)&(*(uint8_t**)base)[offset] = i; }
# Line 491  namespace LinuxSampler { Line 547  namespace LinuxSampler {
547          }          }
548      };      };
549    
550        #if HAVE_CXX_EMBEDDED_PRAGMA_DIAGNOSTICS
551        # define COMPILER_DISABLE_OFFSETOF_WARNING                    \
552            _Pragma("GCC diagnostic push")                            \
553            _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"")
554        # define COMPILER_RESTORE_OFFSETOF_WARNING \
555            _Pragma("GCC diagnostic pop")
556        #else
557        # define COMPILER_DISABLE_OFFSETOF_WARNING
558        # define COMPILER_RESTORE_OFFSETOF_WARNING
559        #endif
560    
561      /**      /**
562       * Convenience macro for initializing VMIntRelPtr and VMInt8RelPtr       * Convenience macro for initializing VMIntRelPtr and VMInt8RelPtr
563       * structures. Usage example:       * structures. Usage example:
# Line 533  namespace LinuxSampler { Line 600  namespace LinuxSampler {
600       * complexity inside the sampler engines which provide the actual script       * complexity inside the sampler engines which provide the actual script
601       * functionalities.       * functionalities.
602       */       */
603      #define DECLARE_VMINT(basePtr, T_struct, T_member) ( \      #define DECLARE_VMINT(basePtr, T_struct, T_member) (          \
604          (VMRelPtr) {                                     \          /* Disable offsetof warning, trust us, we are cautios. */ \
605              (void**) &basePtr,                           \          COMPILER_DISABLE_OFFSETOF_WARNING                         \
606              offsetof(T_struct, T_member)                 \          (VMRelPtr) {                                              \
607          }                                                \              (void**) &basePtr,                                    \
608      )                                                    \              offsetof(T_struct, T_member),                         \
609                false                                                 \
610            }                                                         \
611            COMPILER_RESTORE_OFFSETOF_WARNING                         \
612        )                                                             \
613    
614        /**
615         * Same as DECLARE_VMINT(), but this one defines the VMIntRelPtr and
616         * VMInt8RelPtr structures to be of read-only type. That means the script
617         * parser will abort any script at parser time if the script is trying to
618         * modify such a read-only built-in variable.
619         *
620         * @b NOTE: this is only intended for built-in read-only variables that
621         * may change during runtime! If your built-in variable's data is rather
622         * already available at parser time and won't change during runtime, then
623         * you should rather register a built-in constant in your VM class instead!
624         *
625         * @see ScriptVM::builtInConstIntVariables()
626         */
627        #define DECLARE_VMINT_READONLY(basePtr, T_struct, T_member) ( \
628            /* Disable offsetof warning, trust us, we are cautios. */ \
629            COMPILER_DISABLE_OFFSETOF_WARNING                         \
630            (VMRelPtr) {                                              \
631                (void**) &basePtr,                                    \
632                offsetof(T_struct, T_member),                         \
633                true                                                  \
634            }                                                         \
635            COMPILER_RESTORE_OFFSETOF_WARNING                         \
636        )                                                             \
637    
638      /** @brief Built-in VM 8 bit integer array variable.      /** @brief Built-in VM 8 bit integer array variable.
639       *       *
# Line 553  namespace LinuxSampler { Line 648  namespace LinuxSampler {
648          VMInt8Array() : data(NULL), size(0) {}          VMInt8Array() : data(NULL), size(0) {}
649      };      };
650    
651        /** @brief Virtual machine script variable.
652         *
653         * Common interface for all variables accessed in scripts.
654         */
655        class VMVariable : virtual public VMExpr {
656        public:
657            /**
658             * Whether a script may modify the content of this variable by
659             * assigning a new value to it.
660             *
661             * @see isConstExpr(), assign()
662             */
663            virtual bool isAssignable() const = 0;
664    
665            /**
666             * In case this variable is assignable, this method will be called to
667             * perform the value assignment to this variable with @a expr
668             * reflecting the new value to be assigned.
669             *
670             * @param expr - new value to be assigned to this variable
671             */
672            virtual void assignExpr(VMExpr* expr) = 0;
673        };
674        
675      /** @brief Dynamically executed variable (abstract base class).      /** @brief Dynamically executed variable (abstract base class).
676       *       *
677       * Interface for the implementation of a dynamically generated content of       * Interface for the implementation of a dynamically generated content of
# Line 563  namespace LinuxSampler { Line 682  namespace LinuxSampler {
682       * to a dynamic variable some native code is executed to actually generate       * to a dynamic variable some native code is executed to actually generate
683       * and provide the content (value) of this type of variable.       * and provide the content (value) of this type of variable.
684       */       */
685      class VMDynVar : virtual public VMExpr {      class VMDynVar : public VMVariable {
686      public:      public:
687          /**          /**
          * Whether a script may modify the content of this dynamic variable by  
          * assigning a new value to it.  
          *  
          * @see isConstExpr(), assign()  
          */  
         virtual bool isAssignable() const = 0;  
   
         /**  
688           * Returns true in case this dynamic variable can be considered to be a           * Returns true in case this dynamic variable can be considered to be a
689           * constant expression. A constant expression will retain the same value           * constant expression. A constant expression will retain the same value
690           * throughout the entire life time of a script and the expression's           * throughout the entire life time of a script and the expression's
# Line 609  namespace LinuxSampler { Line 720  namespace LinuxSampler {
720           *           *
721           * @see isAssignable()           * @see isAssignable()
722           */           */
723          virtual bool isConstExpr() const { return false; }          bool isConstExpr() const OVERRIDE { return false; }
724    
725          /**          /**
726           * In case this dynamic variable is assignable, the new value (content)           * In case this dynamic variable is assignable, the new value (content)
# Line 621  namespace LinuxSampler { Line 732  namespace LinuxSampler {
732           *           *
733           * @param expr - new value to be assigned to this variable           * @param expr - new value to be assigned to this variable
734           */           */
735          virtual void assign(VMExpr* expr) {}          void assignExpr(VMExpr* expr) OVERRIDE {}
736    
737            virtual ~VMDynVar() {}
738      };      };
739    
740      /** @brief Dynamically executed variable (of integer data type).      /** @brief Dynamically executed variable (of integer data type).
# Line 762  namespace LinuxSampler { Line 875  namespace LinuxSampler {
875       * issue (either a parser error or parser warning), a human readable       * issue (either a parser error or parser warning), a human readable
876       * explanation text of the error or warning and the location of the       * explanation text of the error or warning and the location of the
877       * encountered parser issue within the script.       * encountered parser issue within the script.
878         *
879         * @see VMSourceToken for processing syntax highlighting instead.
880       */       */
881      struct ParserIssue {      struct ParserIssue {
882          String txt; ///< Human readable explanation text of the parser issue.          String txt; ///< Human readable explanation text of the parser issue.
# Line 880  namespace LinuxSampler { Line 995  namespace LinuxSampler {
995       * This class is not actually used by the sampler itself. It is rather       * This class is not actually used by the sampler itself. It is rather
996       * provided for external script editor applications. Primary purpose of       * provided for external script editor applications. Primary purpose of
997       * this class is syntax highlighting for external script editors.       * this class is syntax highlighting for external script editors.
998         *
999         * @see ParserIssue for processing compile errors and warnings instead.
1000       */       */
1001      class VMSourceToken {      class VMSourceToken {
1002      public:      public:
# Line 892  namespace LinuxSampler { Line 1009  namespace LinuxSampler {
1009          String text() const;          String text() const;
1010    
1011          // position of token in script          // position of token in script
1012          int firstLine() const; ///< First line this source token is located at in script source code (indexed with 0 being the very first line).          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.
1013          int firstColumn() const; ///< Last line this source token is located at in script source code.          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().
1014    
1015          // base types          // base types
1016          bool isEOF() const;          bool isEOF() const; ///< Returns true in case this source token represents the end of the source code file.
1017          bool isNewLine() const;          bool isNewLine() const; ///< Returns true in case this source token represents a line feed character (i.e. "\n" on Unix systems).
1018          bool isKeyword() const;          bool isKeyword() const; ///< Returns true in case this source token represents a language keyword (i.e. "while", "function", "declare", "on", etc.).
1019          bool isVariableName() const;          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.
1020          bool isIdentifier() const;          bool isIdentifier() const; ///< Returns true in case this source token represents an identifier, which currently always means a function name.
1021          bool isNumberLiteral() const;          bool isNumberLiteral() const; ///< Returns true in case this source token represents a number literal (i.e. 123).
1022          bool isStringLiteral() const;          bool isStringLiteral() const; ///< Returns true in case this source token represents a string literal (i.e. "Some text").
1023          bool isComment() const;          bool isComment() const; ///< Returns true in case this source token represents a source code comment.
1024          bool isPreprocessor() const;          bool isPreprocessor() const; ///< Returns true in case this source token represents a preprocessor statement.
1025          bool isOther() const;          bool isOther() const; ///< Returns true in case this source token represents anything else not covered by the token types mentioned above.
1026    
1027          // extended types          // extended types
1028          bool isIntegerVariable() const;          bool isIntegerVariable() const; ///< Returns true in case this source token represents an integer variable name (i.e. "$someIntVariable").
1029          bool isStringVariable() const;          bool isStringVariable() const; ///< Returns true in case this source token represents an string variable name (i.e. "\@someStringVariable").
1030          bool isArrayVariable() const;          bool isArrayVariable() const; ///< Returns true in case this source token represents an array variable name (i.e. "%someArryVariable").
1031          bool isEventHandlerName() const;          bool isEventHandlerName() const; ///< Returns true in case this source token represents an event handler name (i.e. "note", "release", "controller").
1032    
1033          VMSourceToken& operator=(const VMSourceToken& other);          VMSourceToken& operator=(const VMSourceToken& other);
1034    
Legend:
Removed from v.2942  
changed lines
  Added in v.3056
  ViewVC Help
Powered by ViewVC