1  /** @file


2  * VBox HDD container test utility  scripting engine, AST related structures.


3  */


4 


5  /*


6  * Copyright (C) 20132016 Oracle Corporation


7  *


8  * This file is part of VirtualBox Open Source Edition (OSE), as


9  * available from http://www.virtualbox.org. This file is free software;


10  * you can redistribute it and/or modify it under the terms of the GNU


11  * General Public License (GPL) as published by the Free Software


12  * Foundation, in version 2 as it comes in the "COPYING" file of the


13  * VirtualBox OSE distribution. VirtualBox OSE is distributed in the


14  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.


15  */


16 


17  #ifndef ___VDScriptAst_h___


18  #define ___VDScriptAst_h___


19 


20  #include <iprt/list.h>


21 


22  /**


23  * Position information.


24  */


25  typedef struct VDSRCPOS


26  {


27  /** Line in the source. */


28  unsigned iLine;


29  /** Current start character .*/


30  unsigned iChStart;


31  /** Current end character. */


32  unsigned iChEnd;


33  } VDSRCPOS;


34  /** Pointer to a source position. */


35  typedef struct VDSRCPOS *PVDSRCPOS;


36 


37  /**


38  * AST node classes.


39  */


40  typedef enum VDSCRIPTASTCLASS


41  {


42  /** Invalid. */


43  VDSCRIPTASTCLASS_INVALID = 0,


44  /** Function node. */


45  VDSCRIPTASTCLASS_FUNCTION,


46  /** Function argument. */


47  VDSCRIPTASTCLASS_FUNCTIONARG,


48  /** Identifier node. */


49  VDSCRIPTASTCLASS_IDENTIFIER,


50  /** Declaration node. */


51  VDSCRIPTASTCLASS_DECLARATION,


52  /** Statement node. */


53  VDSCRIPTASTCLASS_STATEMENT,


54  /** Expression node. */


55  VDSCRIPTASTCLASS_EXPRESSION,


56  /** Type name node. */


57  VDSCRIPTASTCLASS_TYPENAME,


58  /** Type specifier node. */


59  VDSCRIPTASTCLASS_TYPESPECIFIER,


60  /** 32bit blowup. */


61  VDSCRIPTASTCLASS_32BIT_HACK = 0x7fffffff


62  } VDSCRIPTASTCLASS;


63  /** Pointer to an AST node class. */


64  typedef VDSCRIPTASTCLASS *PVDSCRIPTASTCLASS;


65 


66  /**


67  * Core AST structure.


68  */


69  typedef struct VDSCRIPTASTCORE


70  {


71  /** The node class, used for verification. */


72  VDSCRIPTASTCLASS enmClass;


73  /** List which might be used. */


74  RTLISTNODE ListNode;


75  /** Position in the source file of this node. */


76  VDSRCPOS Pos;


77  } VDSCRIPTASTCORE;


78  /** Pointer to an AST core structure. */


79  typedef VDSCRIPTASTCORE *PVDSCRIPTASTCORE;


80 


81  /** Pointer to an statement node  forward declaration. */


82  typedef struct VDSCRIPTASTSTMT *PVDSCRIPTASTSTMT;


83  /** Pointer to an expression node  forward declaration. */


84  typedef struct VDSCRIPTASTEXPR *PVDSCRIPTASTEXPR;


85 


86  /**


87  * AST identifier node.


88  */


89  typedef struct VDSCRIPTASTIDE


90  {


91  /** Core structure. */


92  VDSCRIPTASTCORE Core;


93  /** Number of characters in the identifier, excluding the zero terminator. */


94  unsigned cchIde;


95  /** Identifier, variable size. */


96  char aszIde[1];


97  } VDSCRIPTASTIDE;


98  /** Pointer to an identifer node. */


99  typedef VDSCRIPTASTIDE *PVDSCRIPTASTIDE;


100 


101  /**


102  * Type specifier.


103  */


104  typedef enum VDSCRIPTASTTYPESPECIFIER


105  {


106  /** Invalid type specifier. */


107  VDSCRIPTASTTYPESPECIFIER_INVALID = 0,


108  /** Union type specifier. */


109  VDSCRIPTASTTYPESPECIFIER_UNION,


110  /** Struct type specifier. */


111  VDSCRIPTASTTYPESPECIFIER_STRUCT,


112  /** Identifier of a typedefed type. */


113  VDSCRIPTASTTYPESPECIFIER_IDE,


114  /** 32bit hack. */


115  VDSCRIPTASTTYPESPECIFIER_32BIT_HACK = 0x7fffffff


116  } VDSCRIPTASTTYPESPECIFIER;


117  /** Pointer to a typespecifier. */


118  typedef VDSCRIPTASTTYPESPECIFIER *PVDSCRIPTASTTYPESPECIFIER;


119 


120  /**


121  * AST type specifier.


122  */


123  typedef struct VDSCRIPTASTTYPESPEC


124  {


125  /** Core structure. */


126  VDSCRIPTASTCORE Core;


127  /** Specifier type. */


128  VDSCRIPTASTTYPESPECIFIER enmType;


129  /** Type dependent data .*/


130  union


131  {


132  /** Pointer to an identifier for typedefed types. */


133  PVDSCRIPTASTIDE pIde;


134  /** struct or union specifier. */


135  struct


136  {


137  /** Pointer to the identifier, optional. */


138  PVDSCRIPTASTIDE pIde;


139  /** Declaration list  VDSCRIPTAST. */


140  RTLISTANCHOR ListDecl;


141  } StructUnion;


142  };


143  } VDSCRIPTASTTYPESPEC;


144  /** Pointer to an AST type specifier. */


145  typedef VDSCRIPTASTTYPESPEC *PVDSCRIPTASTTYPESPEC;


146 


147  /**


148  * Storage clase specifier.


149  */


150  typedef enum VDSCRIPTASTSTORAGECLASS


151  {


152  /** Invalid storage class sepcifier. */


153  VDSCRIPTASTSTORAGECLASS_INVALID = 0,


154  /** A typedef type. */


155  VDSCRIPTASTSTORAGECLASS_TYPEDEF,


156  /** An external declared object. */


157  VDSCRIPTASTSTORAGECLASS_EXTERN,


158  /** A static declared object. */


159  VDSCRIPTASTSTORAGECLASS_STATIC,


160  /** Auto object. */


161  VDSCRIPTASTSTORAGECLASS_AUTO,


162  /** Object should be stored in a register. */


163  VDSCRIPTASTSTORAGECLASS_REGISTER,


164  /** 32bit hack. */


165  VDSCRIPTASTSTORAGECLASS_32BIT_HACK = 0x7fffffff


166  } VDSCRIPTASTSTORAGECLASS;


167  /** Pointer to a storage class. */


168  typedef VDSCRIPTASTSTORAGECLASS *PVDSCRIPTASTSTORAGECLASS;


169 


170  /**


171  * Type qualifier.


172  */


173  typedef enum VDSCRIPTASTTYPEQUALIFIER


174  {


175  /** Invalid type qualifier. */


176  VDSCRIPTASTTYPEQUALIFIER_INVALID = 0,


177  /** Const type qualifier. */


178  VDSCRIPTASTTYPEQUALIFIER_CONST,


179  /** Restrict type qualifier. */


180  VDSCRIPTASTTYPEQUALIFIER_RESTRICT,


181  /** Volatile type qualifier. */


182  VDSCRIPTASTTYPEQUALIFIER_VOLATILE,


183  /** 32bit hack. */


184  VDSCRIPTASTTYPEQUALIFIER_32BIT_HACK = 0x7fffffff


185  } VDSCRIPTASTTYPEQUALIFIER;


186  /** Pointer to a type qualifier. */


187  typedef VDSCRIPTASTTYPEQUALIFIER *PVDSCRIPTASTTYPEQUALIFIER;


188 


189  /**


190  * AST type name node.


191  */


192  typedef struct VDSCRIPTASTTYPENAME


193  {


194  /** Core structure. */


195  VDSCRIPTASTCORE Core;


196  } VDSCRIPTASTTYPENAME;


197  /** Pointer to a type name node. */


198  typedef VDSCRIPTASTTYPENAME *PVDSCRIPTASTTYPENAME;


199 


200  /**


201  * AST declaration node.


202  */


203  typedef struct VDSCRIPTASTDECL


204  {


205  /** Core structure. */


206  VDSCRIPTASTCORE Core;


207  /** @todo */


208  } VDSCRIPTASTDECL;


209  /** Pointer to an declaration node. */


210  typedef VDSCRIPTASTDECL *PVDSCRIPTASTDECL;


211 


212  /**


213  * Expression types.


214  */


215  typedef enum VDSCRIPTEXPRTYPE


216  {


217  /** Invalid. */


218  VDSCRIPTEXPRTYPE_INVALID = 0,


219  /** Numerical constant. */


220  VDSCRIPTEXPRTYPE_PRIMARY_NUMCONST,


221  /** String constant. */


222  VDSCRIPTEXPRTYPE_PRIMARY_STRINGCONST,


223  /** Boolean constant. */


224  VDSCRIPTEXPRTYPE_PRIMARY_BOOLEAN,


225  /** Identifier. */


226  VDSCRIPTEXPRTYPE_PRIMARY_IDENTIFIER,


227  /** List of assignment expressions as in a = b = c = ... . */


228  VDSCRIPTEXPRTYPE_ASSIGNMENT_LIST,


229  /** Postfix increment expression. */


230  VDSCRIPTEXPRTYPE_POSTFIX_INCREMENT,


231  /** Postfix decrement expression. */


232  VDSCRIPTEXPRTYPE_POSTFIX_DECREMENT,


233  /** Postfix function call expression. */


234  VDSCRIPTEXPRTYPE_POSTFIX_FNCALL,


235  /** Postfix dereference expression. */


236  VDSCRIPTEXPRTYPE_POSTFIX_DEREFERENCE,


237  /** Dot operator (@todo: Is there a better name for it?). */


238  VDSCRIPTEXPRTYPE_POSTFIX_DOT,


239  /** Unary increment expression. */


240  VDSCRIPTEXPRTYPE_UNARY_INCREMENT,


241  /** Unary decrement expression. */


242  VDSCRIPTEXPRTYPE_UNARY_DECREMENT,


243  /** Unary positive sign expression. */


244  VDSCRIPTEXPRTYPE_UNARY_POSSIGN,


245  /** Unary negtive sign expression. */


246  VDSCRIPTEXPRTYPE_UNARY_NEGSIGN,


247  /** Unary invert expression. */


248  VDSCRIPTEXPRTYPE_UNARY_INVERT,


249  /** Unary negate expression. */


250  VDSCRIPTEXPRTYPE_UNARY_NEGATE,


251  /** Unary reference expression. */


252  VDSCRIPTEXPRTYPE_UNARY_REFERENCE,


253  /** Unary dereference expression. */


254  VDSCRIPTEXPRTYPE_UNARY_DEREFERENCE,


255  /** Cast expression. */


256  VDSCRIPTEXPRTYPE_CAST,


257  /** Multiplicative expression. */


258  VDSCRIPTEXPRTYPE_MULTIPLICATION,


259  /** Division expression. */


260  VDSCRIPTEXPRTYPE_DIVISION,


261  /** Modulus expression. */


262  VDSCRIPTEXPRTYPE_MODULUS,


263  /** Addition expression. */


264  VDSCRIPTEXPRTYPE_ADDITION,


265  /** Subtraction expression. */


266  VDSCRIPTEXPRTYPE_SUBTRACTION,


267  /** Logical shift right. */


268  VDSCRIPTEXPRTYPE_LSR,


269  /** Logical shift left. */


270  VDSCRIPTEXPRTYPE_LSL,


271  /** Lower than expression */


272  VDSCRIPTEXPRTYPE_LOWER,


273  /** Higher than expression */


274  VDSCRIPTEXPRTYPE_HIGHER,


275  /** Lower or equal than expression */


276  VDSCRIPTEXPRTYPE_LOWEREQUAL,


277  /** Higher or equal than expression */


278  VDSCRIPTEXPRTYPE_HIGHEREQUAL,


279  /** Equals expression */


280  VDSCRIPTEXPRTYPE_EQUAL,


281  /** Not equal expression */


282  VDSCRIPTEXPRTYPE_NOTEQUAL,


283  /** Bitwise and expression */


284  VDSCRIPTEXPRTYPE_BITWISE_AND,


285  /** Bitwise xor expression */


286  VDSCRIPTEXPRTYPE_BITWISE_XOR,


287  /** Bitwise or expression */


288  VDSCRIPTEXPRTYPE_BITWISE_OR,


289  /** Logical and expression */


290  VDSCRIPTEXPRTYPE_LOGICAL_AND,


291  /** Logical or expression */


292  VDSCRIPTEXPRTYPE_LOGICAL_OR,


293  /** Assign expression */


294  VDSCRIPTEXPRTYPE_ASSIGN,


295  /** Multiplicative assign expression */


296  VDSCRIPTEXPRTYPE_ASSIGN_MULT,


297  /** Division assign expression */


298  VDSCRIPTEXPRTYPE_ASSIGN_DIV,


299  /** Modulus assign expression */


300  VDSCRIPTEXPRTYPE_ASSIGN_MOD,


301  /** Additive assign expression */


302  VDSCRIPTEXPRTYPE_ASSIGN_ADD,


303  /** Subtractive assign expression */


304  VDSCRIPTEXPRTYPE_ASSIGN_SUB,


305  /** Bitwise left shift assign expression */


306  VDSCRIPTEXPRTYPE_ASSIGN_LSL,


307  /** Bitwise right shift assign expression */


308  VDSCRIPTEXPRTYPE_ASSIGN_LSR,


309  /** Bitwise and assign expression */


310  VDSCRIPTEXPRTYPE_ASSIGN_AND,


311  /** Bitwise xor assign expression */


312  VDSCRIPTEXPRTYPE_ASSIGN_XOR,


313  /** Bitwise or assign expression */


314  VDSCRIPTEXPRTYPE_ASSIGN_OR,


315  /** 32bit hack. */


316  VDSCRIPTEXPRTYPE_32BIT_HACK = 0x7fffffff


317  } VDSCRIPTEXPRTYPE;


318  /** Pointer to an expression type. */


319  typedef VDSCRIPTEXPRTYPE *PVDSCRIPTEXPRTYPE;


320 


321  /**


322  * AST expression node.


323  */


324  typedef struct VDSCRIPTASTEXPR


325  {


326  /** Core structure. */


327  VDSCRIPTASTCORE Core;


328  /** Expression type. */


329  VDSCRIPTEXPRTYPE enmType;


330  /** Expression type dependent data. */


331  union


332  {


333  /** Numerical constant. */


334  uint64_t u64;


335  /** Primary identifier. */


336  PVDSCRIPTASTIDE pIde;


337  /** String literal */


338  const char *pszStr;


339  /** Boolean constant. */


340  bool f;


341  /** List of expressions  VDSCRIPTASTEXPR. */


342  RTLISTANCHOR ListExpr;


343  /** Pointer to another expression. */


344  PVDSCRIPTASTEXPR pExpr;


345  /** Function call expression. */


346  struct


347  {


348  /** Other postfix expression used as the identifier for the function. */


349  PVDSCRIPTASTEXPR pFnIde;


350  /** Argument list if existing. */


351  RTLISTANCHOR ListArgs;


352  } FnCall;


353  /** Binary operation. */


354  struct


355  {


356  /** Left operator. */


357  PVDSCRIPTASTEXPR pLeftExpr;


358  /** Right operator. */


359  PVDSCRIPTASTEXPR pRightExpr;


360  } BinaryOp;


361  /** Dereference or dot operation. */


362  struct


363  {


364  /** The identifier to access. */


365  PVDSCRIPTASTIDE pIde;


366  /** Postfix expression coming after this. */


367  PVDSCRIPTASTEXPR pExpr;


368  } Deref;


369  /** Cast expression. */


370  struct


371  {


372  /** Type name. */


373  PVDSCRIPTASTTYPENAME pTypeName;


374  /** Following cast expression. */


375  PVDSCRIPTASTEXPR pExpr;


376  } Cast;


377  };


378  } VDSCRIPTASTEXPR;


379 


380  /**


381  * AST if node.


382  */


383  typedef struct VDSCRIPTASTIF


384  {


385  /** Conditional expression. */


386  PVDSCRIPTASTEXPR pCond;


387  /** The true branch */


388  PVDSCRIPTASTSTMT pTrueStmt;


389  /** The else branch, can be NULL if no else branch. */


390  PVDSCRIPTASTSTMT pElseStmt;


391  } VDSCRIPTASTIF;


392  /** Pointer to an expression node. */


393  typedef VDSCRIPTASTIF *PVDSCRIPTASTIF;


394 


395  /**


396  * AST switch node.


397  */


398  typedef struct VDSCRIPTASTSWITCH


399  {


400  /** Conditional expression. */


401  PVDSCRIPTASTEXPR pCond;


402  /** The statement to follow. */


403  PVDSCRIPTASTSTMT pStmt;


404  } VDSCRIPTASTSWITCH;


405  /** Pointer to an expression node. */


406  typedef VDSCRIPTASTSWITCH *PVDSCRIPTASTSWITCH;


407 


408  /**


409  * AST while or do ... while node.


410  */


411  typedef struct VDSCRIPTASTWHILE


412  {


413  /** Flag whether this is a do while loop. */


414  bool fDoWhile;


415  /** Conditional expression. */


416  PVDSCRIPTASTEXPR pCond;


417  /** The statement to follow. */


418  PVDSCRIPTASTSTMT pStmt;


419  } VDSCRIPTASTWHILE;


420  /** Pointer to an expression node. */


421  typedef VDSCRIPTASTWHILE *PVDSCRIPTASTWHILE;


422 


423  /**


424  * AST for node.


425  */


426  typedef struct VDSCRIPTASTFOR


427  {


428  /** Initializer expression. */


429  PVDSCRIPTASTEXPR pExprStart;


430  /** The exit condition. */


431  PVDSCRIPTASTEXPR pExprCond;


432  /** The third expression (normally used to increase/decrease loop variable). */


433  PVDSCRIPTASTEXPR pExpr3;


434  /** The for loop body. */


435  PVDSCRIPTASTSTMT pStmt;


436  } VDSCRIPTASTFOR;


437  /** Pointer to an expression node. */


438  typedef VDSCRIPTASTFOR *PVDSCRIPTASTFOR;


439 


440  /**


441  * Statement types.


442  */


443  typedef enum VDSCRIPTSTMTTYPE


444  {


445  /** Invalid. */


446  VDSCRIPTSTMTTYPE_INVALID = 0,


447  /** Compound statement. */


448  VDSCRIPTSTMTTYPE_COMPOUND,


449  /** Expression statement. */


450  VDSCRIPTSTMTTYPE_EXPRESSION,


451  /** if statement. */


452  VDSCRIPTSTMTTYPE_IF,


453  /** switch statement. */


454  VDSCRIPTSTMTTYPE_SWITCH,


455  /** while statement. */


456  VDSCRIPTSTMTTYPE_WHILE,


457  /** for statement. */


458  VDSCRIPTSTMTTYPE_FOR,


459  /** continue statement. */


460  VDSCRIPTSTMTTYPE_CONTINUE,


461  /** break statement. */


462  VDSCRIPTSTMTTYPE_BREAK,


463  /** return statement. */


464  VDSCRIPTSTMTTYPE_RETURN,


465  /** case statement. */


466  VDSCRIPTSTMTTYPE_CASE,


467  /** default statement. */


468  VDSCRIPTSTMTTYPE_DEFAULT,


469  /** 32bit hack. */


470  VDSCRIPTSTMTTYPE_32BIT_HACK = 0x7fffffff


471  } VDSCRIPTSTMTTYPE;


472  /** Pointer to a statement type. */


473  typedef VDSCRIPTSTMTTYPE *PVDSCRIPTSTMTTYPE;


474 


475  /**


476  * AST statement node.


477  */


478  typedef struct VDSCRIPTASTSTMT


479  {


480  /** Core structure. */


481  VDSCRIPTASTCORE Core;


482  /** Statement type */


483  VDSCRIPTSTMTTYPE enmStmtType;


484  /** Statement type dependent data. */


485  union


486  {


487  /** Compound statement. */


488  struct


489  {


490  /** List of declarations  VDSCRIPTASTDECL. */


491  RTLISTANCHOR ListDecls;


492  /** List of statements  VDSCRIPTASTSTMT. */


493  RTLISTANCHOR ListStmts;


494  } Compound;


495  /** case, default statement. */


496  struct


497  {


498  /** Pointer to the expression. */


499  PVDSCRIPTASTEXPR pExpr;


500  /** Pointer to the statement. */


501  PVDSCRIPTASTSTMT pStmt;


502  } Case;


503  /** "if" statement. */


504  VDSCRIPTASTIF If;


505  /** "switch" statement. */


506  VDSCRIPTASTSWITCH Switch;


507  /** "while" or "do ... while" loop. */


508  VDSCRIPTASTWHILE While;


509  /** "for" loop. */


510  VDSCRIPTASTFOR For;


511  /** Pointer to another statement. */


512  PVDSCRIPTASTSTMT pStmt;


513  /** Expression statement. */


514  PVDSCRIPTASTEXPR pExpr;


515  };


516  } VDSCRIPTASTSTMT;


517 


518  /**


519  * AST node for one function argument.


520  */


521  typedef struct VDSCRIPTASTFNARG


522  {


523  /** Core structure. */


524  VDSCRIPTASTCORE Core;


525  /** Identifier describing the type of the argument. */


526  PVDSCRIPTASTIDE pType;


527  /** The name of the argument. */


528  PVDSCRIPTASTIDE pArgIde;


529  } VDSCRIPTASTFNARG;


530  /** Pointer to a AST function argument node. */


531  typedef VDSCRIPTASTFNARG *PVDSCRIPTASTFNARG;


532 


533  /**


534  * AST node describing a function.


535  */


536  typedef struct VDSCRIPTASTFN


537  {


538  /** Core structure. */


539  VDSCRIPTASTCORE Core;


540  /** Identifier describing the return type. */


541  PVDSCRIPTASTIDE pRetType;


542  /** Name of the function. */


543  PVDSCRIPTASTIDE pFnIde;


544  /** Number of arguments in the list. */


545  unsigned cArgs;


546  /** Argument list  VDSCRIPTASTFNARG. */


547  RTLISTANCHOR ListArgs;


548  /** Compound statement node. */


549  PVDSCRIPTASTSTMT pCompoundStmts;


550  } VDSCRIPTASTFN;


551  /** Pointer to a function AST node. */


552  typedef VDSCRIPTASTFN *PVDSCRIPTASTFN;


553 


554  /**


555  * Free the given AST node and all subsequent nodes pointed to


556  * by the given node.


557  *


558  * @returns nothing.


559  * @param pAstNode The AST node to free.


560  */


561  DECLHIDDEN(void) vdScriptAstNodeFree(PVDSCRIPTASTCORE pAstNode);


562 


563  /**


564  * Allocate a non variable in size AST node of the given class.


565  *


566  * @returns Pointer to the allocated node.


567  * NULL if out of memory.


568  * @param enmClass The class of the AST node.


569  */


570  DECLHIDDEN(PVDSCRIPTASTCORE) vdScriptAstNodeAlloc(VDSCRIPTASTCLASS enmClass);


571 


572  /**


573  * Allocate a IDE node which can hold the given number of characters.


574  *


575  * @returns Pointer to the allocated node.


576  * NULL if out of memory.


577  * @param cchIde Number of characters which can be stored in the node.


578  */


579  DECLHIDDEN(PVDSCRIPTASTIDE) vdScriptAstNodeIdeAlloc(size_t cchIde);


580 


581  #endif


582 

