修复tuple操作中存在栈数据时会导致程序崩溃

支持在windows下编译

Author: zccrs

.gitignore

@@ -32,6 +32,7 @@ qrc_*.cpp
 ui_*.h
 Makefile*
 *build-*
+build
 
 # QtCreator
 

3rdparty/FlexLexer.h

@@ -0,0 +1,220 @@
+// -*-C++-*-
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+// by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+
+//  1. Redistributions of source code must retain the above copyright
+//  notice, this list of conditions and the following disclaimer.
+//  2. Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+
+//  Neither the name of the University nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+
+//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//      #undef yyFlexLexer
+//      #define yyFlexLexer xxFlexLexer
+//      #include <FlexLexer.h>
+//
+//      #undef yyFlexLexer
+//      #define yyFlexLexer zzFlexLexer
+//      #include <FlexLexer.h>
+//      ...
+
+#ifndef __FLEX_LEXER_H
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+
+#include <iostream>
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer
+{
+public:
+  virtual ~FlexLexer()        { }
+
+  const char* YYText() const  { return yytext; }
+  int YYLeng()        const   { return yyleng; }
+
+  virtual void
+  yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
+  virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
+  virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
+  virtual void yyrestart( std::istream* s ) = 0;
+  virtual void yyrestart( std::istream& s ) = 0;
+
+  virtual int yylex() = 0;
+
+  // Call yylex with new input/output sources.
+  int yylex( std::istream& new_in, std::ostream& new_out )
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  int yylex( std::istream* new_in, std::ostream* new_out = 0)
+  {
+    switch_streams( new_in, new_out );
+    return yylex();
+  }
+
+  // Switch to new input/output streams.  A nil stream pointer
+  // indicates "keep the current one".
+  virtual void switch_streams( std::istream* new_in,
+                               std::ostream* new_out ) = 0;
+  virtual void switch_streams( std::istream& new_in,
+                               std::ostream& new_out ) = 0;
+
+  int lineno() const          { return yylineno; }
+
+  int debug() const           { return yy_flex_debug; }
+  void set_debug( int flag )  { yy_flex_debug = flag; }
+
+protected:
+  char* yytext;
+  int yyleng;
+  int yylineno;       // only maintained if you use %option yylineno
+  int yy_flex_debug;  // only has effect with -d or "%option debug"
+};
+
+}
+#endif // FLEXLEXER_H
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex manual.
+# define yyFlexLexerOnce
+
+extern "C++" {
+
+class yyFlexLexer : public FlexLexer {
+public:
+  // arg_yyin and arg_yyout default to the cin and cout, but we
+  // only make that assignment when initializing in yylex().
+  yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
+  yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
+private:
+  void ctor_common();
+
+public:
+
+  virtual ~yyFlexLexer();
+
+  void yy_switch_to_buffer( yy_buffer_state* new_buffer );
+  yy_buffer_state* yy_create_buffer( std::istream* s, int size );
+  yy_buffer_state* yy_create_buffer( std::istream& s, int size );
+  void yy_delete_buffer( yy_buffer_state* b );
+  void yyrestart( std::istream* s );
+  void yyrestart( std::istream& s );
+
+  void yypush_buffer_state( yy_buffer_state* new_buffer );
+  void yypop_buffer_state();
+
+  virtual int yylex();
+  virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
+  virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
+  virtual int yywrap();
+
+protected:
+  virtual int LexerInput( char* buf, int max_size );
+  virtual void LexerOutput( const char* buf, int size );
+  virtual void LexerError( const char* msg );
+
+  void yyunput( int c, char* buf_ptr );
+  int yyinput();
+
+  void yy_load_buffer_state();
+  void yy_init_buffer( yy_buffer_state* b, std::istream& s );
+  void yy_flush_buffer( yy_buffer_state* b );
+
+  int yy_start_stack_ptr;
+  int yy_start_stack_depth;
+  int* yy_start_stack;
+
+  void yy_push_state( int new_state );
+  void yy_pop_state();
+  int yy_top_state();
+
+  yy_state_type yy_get_previous_state();
+  yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+  int yy_get_next_buffer();
+
+  std::istream yyin;  // input source for default LexerInput
+  std::ostream yyout; // output sink for default LexerOutput
+
+  // yy_hold_char holds the character lost when yytext is formed.
+  char yy_hold_char;
+
+  // Number of characters read into yy_ch_buf.
+  int yy_n_chars;
+
+  // Points to current character in buffer.
+  char* yy_c_buf_p;
+
+  int yy_init;                // whether we need to initialize
+  int yy_start;               // start state number
+
+  // Flag which is used to allow yywrap()'s to do buffer switches
+  // instead of setting up a fresh yyin.  A bit of a hack ...
+  int yy_did_buffer_switch_on_eof;
+
+
+  size_t yy_buffer_stack_top; /**< index of top of stack. */
+  size_t yy_buffer_stack_max; /**< capacity of stack. */
+  yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+  void yyensure_buffer_stack(void);
+
+  // The following are not always needed, but may be depending
+  // on use of certain flex features (like REJECT or yymore()).
+
+  yy_state_type yy_last_accepting_state;
+  char* yy_last_accepting_cpos;
+
+  yy_state_type* yy_state_buf;
+  yy_state_type* yy_state_ptr;
+
+  char* yy_full_match;
+  int* yy_full_state;
+  int yy_full_lp;
+
+  int yy_lp;
+  int yy_looking_for_trail_begin;
+
+  int yy_more_flag;
+  int yy_more_len;
+  int yy_more_offset;
+  int yy_prev_more_offset;
+};
+
+}
+
+#endif // yyFlexLexer || ! yyFlexLexerOnce

common/zcode.cpp

@@ -354,7 +354,14 @@ ZVariant ZCode::exec(const QList<ZCode *> &codeList)
             tuple.reserve(argsCount);
 
             for(int i = 0; i< argsCount; ++i) {
-                tuple.insert(0, virtualStack.pop());
+                // 栈中的数据都是保存在了temporaryList中
+                // 此函数返回时其中的数据就全部被销毁了，Tuple
+                // 中存储的是指针，指针指向的是temporaryList中的数据
+                // 此exec可能是被其他函数调用的，因此Tuple中
+                // 存储的可能是栈变量，函数执行结束后被其他作用
+                // 域调用则访问到了无效指针，因此这里要new一个
+                // 新的ZVariant
+                tuple.prepend(new ZVariant(*virtualStack.pop()));
             }
 
             temporaryList << std::move(tuple);

common/zglobal.h

@@ -11,7 +11,7 @@
 #define zWarning qWarning().noquote() << "[Warning]:"
 #define zPrint qDebug().noquote()
 #define zStandardPrint std::cout
-#define zExit(code) quick_exit(code)
+#define zExit(code) exit(code)
 #define zErrorQuit zExit(-1)
 #define zQuit zExit(0)
 

common/zvariant.cpp

@@ -48,7 +48,7 @@ ZVariant::ZVariant(const ZVariant &other)
 
 ZVariant::ZVariant(ZVariant &&other)
 {
-    qSwap(m_data, other.m_data);
+    m_data.swap(other.m_data);
 }
 
 ZVariant::ZVariant(const QString &val)
@@ -681,6 +681,7 @@ ZVariant operator ~(const ZVariant &var)
 
 Z_END_NAMESPACE
 
+QT_BEGIN_NAMESPACE
 QDebug operator<<(QDebug deg, const ZVariant &var)
 {
     deg.nospace() << "Variant(" << var.typeName() << ", ";
@@ -713,7 +714,6 @@ QDebug operator<<(QDebug deg, const ZVariant &var)
     return deg;
 }
 
-QT_BEGIN_NAMESPACE
 uint qHash(const ZVariant &val, uint seed)
 {
     switch (val.type()) {

common/zvariant.h

@@ -99,7 +99,19 @@ class ZVariant
 
         VariantData *data = const_cast<VariantData*>(this->m_data.constData());
 
-        data->variant = other.m_data->variant;
+        if (other.type() == Tuple) {
+            // 元组类型由于存储的是指针，因此也要深度复制
+            ZTuple tuple;
+
+            for (const ZVariant *i : other.toTuple()) {
+                tuple << new ZVariant(*i);
+            }
+
+            data->variant = QVariant::fromValue(tuple);
+        } else {
+            data->variant = other.m_data->variant;
+        }
+
         data->type = other.m_data->type;
     }
 
@@ -130,10 +142,10 @@ class ZVariant
             int min = qMin(other_group.count(), this_group.count());
 
             for(int i = 0; i < min; ++i) {
-                qSwap(this_group[i]->m_data, other_group[i]->m_data);
+                this_group[i]->m_data.swap(other_group[i]->m_data);
             }
         } else {
-            qSwap(m_data, other.m_data);
+            m_data.swap(other.m_data);
         }
 
         return *this;
@@ -215,6 +227,13 @@ class ZVariant
     class VariantData : public QSharedData
     {
     public:
+        ~VariantData() {
+            if (type == Tuple) {
+                // 销毁列表中的数据
+                qDeleteAll(qvariant_cast<ZTuple>(variant));
+            }
+        }
+
         QVariant variant;
         ZVariant::Type type;
     };
@@ -353,7 +372,7 @@ class ZSharedVariant : public ZVariant, public QSharedData
 Z_END_NAMESPACE
 
 QT_BEGIN_NAMESPACE
-Q_CORE_EXPORT QDebug operator<<(QDebug deg, const ZVariant &var);
+QDebug operator<<(QDebug deg, const ZVariant &var);
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(ZVariant)

lexical/lexical.pri

@@ -2,6 +2,7 @@ SOURCES += $$PWD/lex.yy.cpp
 
 OTHER_FILES += $$PWD/zScript.ll
 
-system(flex -+ -o lex.yy.cpp $$PWD/zScript.ll)
+win*: INCLUDEPATH += $$PWD/../3rdparty
+else: system(flex -+ -o lex.yy.cpp $$PWD/zScript.ll)
 
 INCLUDEPATH += $$PWD

syntax/syntax.pri

@@ -6,6 +6,7 @@ SOURCES += \
 
 OTHER_FILES += $$PWD/zScript.yy
 
-system(bison -d -v -L c++ -o zScript.tab.cpp $$PWD/zScript.yy)
+win*: INCLUDEPATH += $$PWD/../3rdparty
+else: system(bison -d -v -L c++ -o zScript.tab.cpp $$PWD/zScript.yy)
 
 INCLUDEPATH += $$PWD

syntax/zScript.yy

@@ -999,7 +999,7 @@ void yy::parser::error(const location_type& loc, const std::string& msg)
     std::cerr << "from " << loc.begin.line << " line " << loc.begin.column << " column, "
               << "to " << loc.end.line << " line " << loc.end.column << " column, " << msg << std::endl;
 
-    quick_exit(-1);
+    exit(-1);
 }
 
 int yylex(yy::parser::semantic_type *lval, yy::parser::location_type *location)