/// <summary> /// Emits dynamic inclusion. /// </summary> private PhpTypeCode EmitDynamicInclusion(CodeGenerator/*!*/ codeGenerator) { // do not generate dynamic auto inclusions: if (InclusionTypesEnum.IsAutoInclusion(inclusionType)) return PhpTypeCode.Void; ILEmitter il = codeGenerator.IL; // CALL context.DynamicInclude(<file name>,<relative includer source path>,variables,self,includer); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitConversion(fileNameEx, PhpTypeCode.String); il.Emit(OpCodes.Ldstr, codeGenerator.SourceUnit.SourceFile.RelativePath.ToString()); codeGenerator.EmitLoadRTVariablesTable(); codeGenerator.EmitLoadSelf(); codeGenerator.EmitLoadClassContext(); il.LoadLiteral(inclusionType); il.Emit(OpCodes.Call, Methods.ScriptContext.DynamicInclude); return PhpTypeCode.Object; }
/// <summary> /// Emits IL instructions that read the value of an instance field. /// </summary> /// <param name="codeGenerator">The current <see cref="CodeGenerator"/>.</param> /// <param name="wantRef">If <B>false</B> the field value should be left on the evaluation stack, /// if <B>true</B> the <see cref="PhpReference"/> should be left on the evaluation stack.</param> /// <returns> /// Nothing is expected on the evaluation stack. A <see cref="PhpReference"/> (if <paramref name="wantRef"/> /// is <B>true</B>) or the field value itself (if <paramref name="wantRef"/> is <B>false</B>) is left on the /// evaluation stack. /// </returns> internal virtual PhpTypeCode EmitReadField(CodeGenerator codeGenerator, bool wantRef) { ILEmitter il = codeGenerator.IL; DirectVarUse direct_instance = isMemberOf as DirectVarUse; if (direct_instance != null && direct_instance.IsMemberOf == null && direct_instance.VarName.IsThisVariableName) { return EmitReadFieldOfThis(codeGenerator, wantRef); } if (!wantRef) { //codeGenerator.ChainBuilder.Lengthen(); //PhpTypeCode type_code = isMemberOf.Emit(codeGenerator); //Debug.Assert(type_code == PhpTypeCode.Object || type_code == PhpTypeCode.DObject); //// CALL Operators.GetProperty(STACK,<field name>,<type desc>,<quiet>); //EmitName(codeGenerator); //codeGenerator.EmitLoadClassContext(); //il.LoadBool(codeGenerator.ChainBuilder.QuietRead); //il.Emit(OpCodes.Call, Methods.Operators.GetProperty); //return PhpTypeCode.Object; string fieldName = (this is DirectVarUse) ? ((DirectVarUse)this).VarName.Value : null; Expression fieldNameExpr = (this is IndirectVarUse) ? ((IndirectVarUse)this).VarNameEx : null; bool quietRead = wantRef ? false : codeGenerator.ChainBuilder.QuietRead; return codeGenerator.CallSitesBuilder.EmitGetProperty( codeGenerator, wantRef, isMemberOf, null, null, null, fieldName, fieldNameExpr, quietRead); } // call GetProperty/GetObjectPropertyRef codeGenerator.ChainBuilder.Lengthen(); // loads the variable which field is gotten: PhpTypeCode var_type_code = isMemberOf.Emit(codeGenerator); if (codeGenerator.ChainBuilder.Exists) { Debug.Assert(var_type_code == PhpTypeCode.DObject); // CALL Operators.GetObjectPropertyRef(STACK,<field name>,<type desc>); EmitName(codeGenerator); codeGenerator.EmitLoadClassContext(); il.Emit(OpCodes.Call, Methods.Operators.GetObjectPropertyRef); } else { Debug.Assert(var_type_code == PhpTypeCode.ObjectAddress); // CALL Operators.GetPropertyRef(ref STACK,<field name>,<type desc>,<script context>); EmitName(codeGenerator); codeGenerator.EmitLoadClassContext(); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.Operators.GetPropertyRef); // stores the value of variable back: SimpleVarUse simple_var = isMemberOf as SimpleVarUse; if (simple_var != null) simple_var.EmitLoadAddress_StoreBack(codeGenerator); } return PhpTypeCode.PhpReference; }
/// <summary> /// Stores the value represented by <see cref="TabledLocalAddressStorage"/> to the runtime variables table and /// returns the <see cref="TabledLocalAddressStorage"/> back to <see cref="ILEmitter.temporaryLocals"/>. /// Duplicates the value if requested. /// </summary> /// <param name="codeGenerator">Currently used <see cref="CodeGenerator"/>.</param> /// <param name="duplicate_value">If <c>true</c>, the value of specified local is left on the evaluation stack. /// </param> internal virtual void StoreTabledVariableBack(CodeGenerator codeGenerator, bool duplicate_value) { ILEmitter il = codeGenerator.IL; // CALL Operators.SetVariable(<local variables table>,<name>,<TabledLocalAddressStorage>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); il.Ldloc(TabledLocalAddressStorage); il.Emit(OpCodes.Call, Methods.Operators.SetVariable); // If requested, load the changed value on the evaluation stack if (duplicate_value) il.Ldloc(this.TabledLocalAddressStorage); // Release temporary local il.ReturnTemporaryLocal(this.TabledLocalAddressStorage); }
/// <summary> /// Emits a static inclusion. /// </summary> private PhpTypeCode EmitStaticInclusion(CodeGenerator/*!*/ codeGenerator) { ILEmitter il = codeGenerator.IL; Label endif_label = il.DefineLabel(); Label else_label = il.DefineLabel(); MethodInfo method; // if the expression should be emitted: if (characteristic == Characteristic.StaticArgEvaluated) { if (!(fileNameEx is StringLiteral || fileNameEx is BinaryStringLiteral)) { // emits expression evaluation and ignores the result: fileNameEx.Emit(codeGenerator); il.Emit(OpCodes.Pop); } } if (characteristic == Characteristic.StaticAutoInclusion) { // calls the Main routine only if this script is the main one: il.Ldarg(ScriptBuilder.ArgIsMain); } else { RelativePath relativePath = new RelativePath(inclusion.Includee.RelativeSourcePath); // normalize the relative path // CALL context.StaticInclude(<relative included script source path>,<this script type>,<inclusion type>); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Ldc_I4, (int)relativePath.Level); il.Emit(OpCodes.Ldstr, relativePath.Path); il.Emit(OpCodes.Ldtoken, inclusion.Includee.ScriptClassType); il.LoadLiteral(inclusionType); il.Emit(OpCodes.Call, Methods.ScriptContext.StaticInclude); } // IF (STACK) il.Emit(OpCodes.Brfalse, else_label); if (true) { // emits a call to the main helper of the included script: method = inclusion.Includee.MainHelper; // CALL <Main>(context, variables, self, includer, false): codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); codeGenerator.EmitLoadSelf(); codeGenerator.EmitLoadClassContext(); il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Call, method); il.Emit(OpCodes.Br, endif_label); } // ELSE il.MarkLabel(else_label); if (true) { // LOAD <PhpScript.SkippedIncludeReturnValue>; il.LoadLiteral(ScriptModule.SkippedIncludeReturnValue); il.Emit(OpCodes.Box, ScriptModule.SkippedIncludeReturnValue.GetType()); } il.MarkLabel(endif_label); // END IF return PhpTypeCode.Object; }
///// <summary> ///// Prepares local variable for a store operation. ///// </summary> //internal void StoreLocalPrepare(CodeGenerator codeGenerator, VariablesTable.Entry variable, LocalBuilder variableName) //{ // Debug.Assert(variable == null ^ variableName == null); //} /// <summary> /// Unsets a specified variable. /// </summary> internal void UnsetLocal(CodeGenerator codeGenerator, VariablesTable.Entry variable, LocalBuilder variableName) { ILEmitter il = codeGenerator.IL; Debug.Assert(variable == null ^ variableName == null); if (variable != null) { if (variable.IsPhpReference) { // <variable> = new PhpReference(); il.Emit(OpCodes.Newobj, Constructors.PhpReference_Void); variable.Variable.EmitStore(il); } else { il.Emit(OpCodes.Ldnull); variable.Variable.EmitStore(il); } } else { // CALL Operators.SetVariable(<local variables table>,<name>,null); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Ldloc(variableName); il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Call, Methods.Operators.SetVariable); } }
/// <summary> /// Loads a value of a specified variable. If the variable is of type <see cref="PhpReference"/>, it is dereferenced. /// </summary> internal void LoadLocal(CodeGenerator codeGenerator, VariablesTable.Entry variable, LocalBuilder variableName) { ILEmitter il = codeGenerator.IL; Debug.Assert(variable == null ^ variableName == null); if (variable != null) { // LOAD DEREF <variable>; variable.Variable.EmitLoad(il); if (variable.IsPhpReference) il.Emit(OpCodes.Ldfld, Fields.PhpReference_Value); } else { // LOAD Operators.GetVariable[Unchecked](<script context>, <local variables table>, <variable name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Ldloc(variableName); if (codeGenerator.ChainBuilder.QuietRead) il.Emit(OpCodes.Call, Methods.Operators.GetVariableUnchecked); else il.Emit(OpCodes.Call, Methods.Operators.GetVariable); } }
internal override void EmitLoadRef(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; if (codeGenerator.OptimizedLocals) { // For IndirectVarUse emit switch over all variables. EmitSwitch(codeGenerator, new SwitchMethod(LoadLocalRef)); } else { // Template: // PhpReference Operators.GetVariableRef(IDictionary table, string name) //returns variable value; variable is of type PhpReference codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); il.Emit(OpCodes.Call, Methods.Operators.GetVariableRef); } }
internal override void EmitUnset(CodeGenerator codeGenerator) { //Template: "unset($$x)" $$x = null; //Template: "unset(x)" x = null Debug.Assert(access == AccessType.Read); // Cases 1, 4, 5, 6, 9 never reached Debug.Assert(codeGenerator.ChainBuilder.IsMember == false); // Case 3 never reached Debug.Assert(codeGenerator.ChainBuilder.IsArrayItem == false); codeGenerator.ChainBuilder.QuietRead = true; // 2, 7, 8 if (this.isMemberOf != null) { // 2: $b->$a // 8: b[]->$a codeGenerator.ChainBuilder.Create(); codeGenerator.ChainBuilder.Begin(); EmitUnsetField(codeGenerator); codeGenerator.ChainBuilder.End(); return; } // 7: $a // Unset this variable //codeGenerator.EmitVariableUnset(this); ILEmitter il = codeGenerator.IL; if (codeGenerator.OptimizedLocals) { // /*copypaste bug*/EmitSwitch(codeGenerator, new SwitchMethod(StoreLocalPrepare)); EmitSwitch(codeGenerator, new SwitchMethod(UnsetLocal)); } else { // CALL Operators.UnsetVariable(<script context>, <local variable table>, <variable name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); il.Emit(OpCodes.Call, Methods.Operators.UnsetVariable); } }
internal override void EmitStorePrepare(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; if (varName.IsThisVariableName) { // Error throwing code will be emitted in EmitVariableStoreAssign } else if (codeGenerator.VariableIsAutoGlobal(varName)) { // Check if the variable is auto-global codeGenerator.EmitAutoGlobalStorePrepare(varName); } else if (codeGenerator.OptimizedLocals) { // Template: // "WRITE($x,value);" // **** // if specified variable is of type PhpReference // ldloc local // **** // Otherwise do nothing VariablesTable.Entry entry = codeGenerator.CurrentVariablesTable[varName]; if (entry.IsPhpReference) { entry.Variable.EmitLoad(il); } // Otherwise do nothing // Now load the value, then call EmitVariableStoreAssignOptimized() to store the value ... } else { // Template: // void Operators.SetVariable(table, "x", PhpVariable.Copy(Operators.getValue(table, "x"), CopyReason.Assigned)); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); // Now load the value, then call SetVariable() to store the value ... } }
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Emit"]/*'/> internal override PhpTypeCode Emit(CodeGenerator/*!*/ codeGenerator) { Debug.Assert(access == AccessType.None || access == AccessType.Read); Statistics.AST.AddNode("ExitEx"); codeGenerator.EmitLoadScriptContext(); if (resultExpr == null) { codeGenerator.IL.Emit(OpCodes.Ldnull); } else { codeGenerator.EmitBoxing(resultExpr.Emit(codeGenerator)); } codeGenerator.IL.Emit(OpCodes.Call, Methods.ScriptContext.Die); if (access == AccessType.Read) { codeGenerator.IL.Emit(OpCodes.Ldnull); return PhpTypeCode.Object; } else return PhpTypeCode.Void; }
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Emit"]/*'/> internal override PhpTypeCode Emit(CodeGenerator/*!*/ codeGenerator) { // not emitted in release mode: Debug.Assert(kind != EvalKinds.LambdaFunction, "Invalid eval kind."); Debug.Assert(kind != EvalKinds.Assert || codeGenerator.Context.Config.Compiler.Debug, "Assert should be cut off in release mode."); Debug.Assert(access == AccessType.None || access == AccessType.Read || access == AccessType.ReadRef); Debug.Assert(inlinedCode != null || codeGenerator.RTVariablesTablePlace != null, "Function should have variables table."); Statistics.AST.AddNode("EvalEx"); ILEmitter il = codeGenerator.IL; PhpTypeCode result; if (inlinedCode != null) { Debug.Assert(kind == EvalKinds.Assert, "Only assert can be inlined so far."); Label endif_label = il.DefineLabel(); Label else_label = il.DefineLabel(); // IF DynamicCode.PreAssert(context) THEN codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.DynamicCode.PreAssert); il.Emit(OpCodes.Brfalse, else_label); if (true) { // LOAD <evaluated assertion>; codeGenerator.EmitBoxing(((Expression)code).Emit(codeGenerator)); // CALL DynamicCode.PostAssert(context); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.DynamicCode.PostAssert); // LOAD bool CheckAssertion(STACK, <inlined code>, context, <source path>, line, column); il.Emit(OpCodes.Ldstr, inlinedCode); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Ldstr, codeGenerator.SourceUnit.SourceFile.RelativePath.ToString()); il.LdcI4(this.position.FirstLine); il.LdcI4(this.position.FirstColumn); codeGenerator.EmitLoadNamingContext(); il.Emit(OpCodes.Call, Methods.DynamicCode.CheckAssertion); // GOTO END IF; il.Emit(OpCodes.Br, endif_label); } // ELSE il.MarkLabel(else_label); if (true) { // LOAD true; il.Emit(OpCodes.Ldc_I4_1); } // END IF; il.MarkLabel(endif_label); result = PhpTypeCode.Object; } else { result = codeGenerator.EmitEval(kind, code, position, currentNamespace, aliases); } // handles return value according to the access type: codeGenerator.EmitReturnValueHandling(this, false, ref result); return result; }
internal void EmitDefinition(CodeGenerator/*!*/ codeGenerator) { if (type.IsComplete) { Debug.Assert(type.IsComplete, "Incomplete types should be converted to evals."); Debug.Assert(type.RealTypeBuilder != null, "A class declared during compilation should have a type builder."); attributes.Emit(codeGenerator, this); typeSignature.Emit(codeGenerator); codeGenerator.EnterTypeDeclaration(type); foreach (TypeMemberDecl member_decl in members) { member_decl.EnterCodegenerator(codeGenerator); member_decl.Emit(codeGenerator); member_decl.LeaveCodegenerator(codeGenerator); } // emit stubs for implemented methods & properties that were not declared by this type: codeGenerator.EmitGhostStubs(type); codeGenerator.LeaveTypeDeclaration(); } else { Debug.Assert(this.typeDefinitionCode != null); // LOAD DynamicCode.Eval(<code>, context, definedVariables, self, includer, source, line, column, evalId) // wrap Eval into static method MethodBuilder method = codeGenerator.IL.TypeBuilder.DefineMethod( string.Format("{0}{1}", ScriptModule.DeclareHelperNane, type.FullName), MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.SpecialName, Types.Void, Types.ScriptContext); var il = new ILEmitter(method); codeGenerator.EnterLambdaDeclaration(il, false, LiteralPlace.Null, new IndexedPlace(PlaceHolder.Argument, 0), LiteralPlace.Null, LiteralPlace.Null); if (true) { codeGenerator.EmitEval( EvalKinds.SyntheticEval, new StringLiteral(position, this.typeDefinitionCode, AccessType.Read), position, (this.Namespace != null) ? this.Namespace.QualifiedName : (QualifiedName?)null, this.validAliases); il.Emit(OpCodes.Pop); il.Emit(OpCodes.Ret); } codeGenerator.LeaveFunctionDeclaration(); // il = codeGenerator.IL; type.IncompleteClassDeclareMethodInfo = method; type.IncompleteClassDeclarationId = String.Format("{0}${1}:{2}:{3}", type.FullName, unchecked((uint)codeGenerator.SourceUnit.SourceFile.ToString().GetHashCode()), position.FirstLine, position.FirstColumn); // sequence point here codeGenerator.MarkSequencePoint(position.FirstLine, position.FirstColumn, position.LastLine, position.LastColumn + 2); if (type.Declaration.IsConditional) { // CALL <Declare>.<FullName>(<context>) codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, method); } else { // if (!<context>.IncompleteTypeDeclared(<id>)) // CALL <Declare>.<FullName>(<context>) var end_if = il.DefineLabel(); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Ldstr, type.IncompleteClassDeclarationId); il.Emit(OpCodes.Call, Methods.ScriptContext.IncompleteTypeDeclared); il.Emit(OpCodes.Brtrue, end_if); if (true) { codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, type.IncompleteClassDeclareMethodInfo); } il.MarkLabel(end_if); il.ForgetLabel(end_if); } } }
internal override void Emit(CodeGenerator/*!*/ codeGenerator) { codeGenerator.MarkSequencePoint( position.FirstLine, position.FirstColumn, position.LastLine, position.LastColumn + 1 ); // CALL Operators.Throw(<context>, <expression>); codeGenerator.EmitLoadScriptContext(); expression.Emit(codeGenerator); codeGenerator.IL.Emit(OpCodes.Call, Methods.Operators.Throw); }
/// <summary> /// Loads the value represented by this object from the runtime variables table, /// stores it to a local variable and loads the address of this local. /// </summary> /// <remarks>This method is used only in non-optimized user functions and global code. /// Specified local variable is obtained from current <see cref="ILEmitter"/> by /// <see cref="ILEmitter.GetTemporaryLocal"/> and stored to <see cref="TabledLocalAddressStorage"/> /// for later use. Once the local become useless, <see cref="ILEmitter.ReturnTemporaryLocal"/> /// should be called. /// </remarks> /// <param name="codeGenerator">Currently used <see cref="CodeGenerator"/>.</param> internal virtual void LoadTabledVariableAddress(CodeGenerator codeGenerator) { // This function should be call only once on every SimpleVarUse object // TODO: ASSERTION FAILS (e.g. PhpMyAdmin, common.lib.php) // Debug.Assert(this.TabledLocalAddressStorage == null); ILEmitter il = codeGenerator.IL; // Load the value represented by this node from the runtime variables table // LOAD Operators.GetVariableUnchecked(<script context>, <local variables table>, <variable name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); codeGenerator.IL.Emit(OpCodes.Call, Methods.Operators.GetVariableUnchecked); // Get local from ILEmitter this.TabledLocalAddressStorage = il.GetTemporaryLocal(Types.Object[0]); // Store the value il.Stloc(this.TabledLocalAddressStorage); // Load the address il.Ldloca(this.TabledLocalAddressStorage); }
internal override void EmitStoreRefPrepare(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; if (varName.IsThisVariableName) { // error throwing code will be emitted in EmitVariableStoreRefAssign } else if (codeGenerator.VariableIsAutoGlobal(varName)) { // Check if the variable is auto-global codeGenerator.EmitAutoGlobalStoreRefPrepare(varName); } else if (codeGenerator.OptimizedLocals) { // Template: // WRITE ref ($x,value); // DO NOTHING !!!! // now load the value then store to local variable } else { // Template: // WRITE ref ($x,value); // by Martin // // ldarg.1 // ldstr "name" // LOAD value // call instance IDictionary.set_Item(object) codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); // now load value, then call EmitVariableStoreRefAssignGlobalContext() to emit stfld ... } }
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Emit"]/*'/> internal override PhpTypeCode Emit(CodeGenerator/*!*/ codeGenerator) { Debug.Assert(access == AccessType.Read || access == AccessType.None); Statistics.AST.AddNode("UnaryEx"); ILEmitter il = codeGenerator.IL; PhpTypeCode returned_typecode, o_typecode; switch (operation) { case Operations.AtSign: // special arrangement // Template: // context.DisableErrorReporting(); // s; // context.EnableErrorReporting(); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.ScriptContext.DisableErrorReporting); returned_typecode = expr.Emit(codeGenerator); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.ScriptContext.EnableErrorReporting); break; case Operations.BitNegation: //Template: "~x" Operators.BitNot(x) codeGenerator.EmitBoxing(expr.Emit(codeGenerator)); il.Emit(OpCodes.Call, Methods.Operators.BitNot); returned_typecode = PhpTypeCode.Object; break; case Operations.Clone: // Template: clone x Operators.Clone(x,DTypeDesc,ScriptContext) codeGenerator.EmitBoxing(expr.Emit(codeGenerator)); codeGenerator.EmitLoadClassContext(); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.Operators.Clone); returned_typecode = PhpTypeCode.Object; break; case Operations.LogicNegation: //Template: "!x" !Convert.ObjectToBoolean(x); if (((returned_typecode = expr.Emit(codeGenerator)) != PhpTypeCode.Boolean)) { codeGenerator.EmitBoxing(returned_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToBoolean); } il.Emit(OpCodes.Ldc_I4_0); il.Emit(OpCodes.Ceq); returned_typecode = PhpTypeCode.Boolean; break; case Operations.Minus: //Template: "-x" Operators.Minus(x) switch (o_typecode = expr.Emit(codeGenerator)) { case PhpTypeCode.Double: il.Emit(OpCodes.Neg); returned_typecode = PhpTypeCode.Double; break; default: codeGenerator.EmitBoxing(o_typecode); returned_typecode = codeGenerator.EmitMethodCall(Methods.Operators.Minus); break; } break; case Operations.ObjectCast: //Template: "(object)x" Convert.ObjectToDObject(x,ScriptContext) codeGenerator.EmitBoxing(expr.Emit(codeGenerator)); codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Call, Methods.Convert.ObjectToDObject); returned_typecode = PhpTypeCode.Object; break; case Operations.Plus: //Template: "+x" Operators.Plus(x) codeGenerator.EmitBoxing(expr.Emit(codeGenerator)); il.Emit(OpCodes.Call, Methods.Operators.Plus); returned_typecode = PhpTypeCode.Object; break; case Operations.Print: codeGenerator.EmitEcho(this.expr); // Always returns 1 il.Emit(OpCodes.Ldc_I4_1); returned_typecode = PhpTypeCode.Integer; break; case Operations.BoolCast: //Template: "(bool)x" Convert.ObjectToBoolean(x) if (((returned_typecode = expr.Emit(codeGenerator)) != PhpTypeCode.Boolean)) { codeGenerator.EmitBoxing(returned_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToBoolean); returned_typecode = PhpTypeCode.Boolean; } break; case Operations.Int8Cast: case Operations.Int16Cast: case Operations.Int32Cast: case Operations.UInt8Cast: case Operations.UInt16Cast: // CALL int Convert.ObjectToInteger(<expr>) o_typecode = expr.Emit(codeGenerator); if (o_typecode != PhpTypeCode.Integer) { codeGenerator.EmitBoxing(o_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToInteger); } // CONV for unsigned: switch (operation) { case Operations.UInt8Cast: il.Emit(OpCodes.Conv_U1); il.Emit(OpCodes.Conv_I4); break; case Operations.UInt16Cast: il.Emit(OpCodes.Conv_U2); il.Emit(OpCodes.Conv_I4); break; } returned_typecode = PhpTypeCode.Integer; break; case Operations.UInt64Cast: case Operations.UInt32Cast: case Operations.Int64Cast: // CALL long Convert.ObjectToLongInteger(<expr>) o_typecode = expr.Emit(codeGenerator); if (o_typecode != PhpTypeCode.LongInteger) { codeGenerator.EmitBoxing(o_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToLongInteger); } // CONV for unsigned: switch (operation) { case Operations.UInt32Cast: il.Emit(OpCodes.Conv_U4); il.Emit(OpCodes.Conv_I8); break; case Operations.UInt64Cast: il.Emit(OpCodes.Conv_U8); il.Emit(OpCodes.Conv_I8); break; } returned_typecode = PhpTypeCode.LongInteger; break; case Operations.DecimalCast: case Operations.DoubleCast: case Operations.FloatCast: // CALL double Convert.ObjectToDouble(<expr>) o_typecode = expr.Emit(codeGenerator); if (o_typecode != PhpTypeCode.Double) { codeGenerator.EmitBoxing(o_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToDouble); } returned_typecode = PhpTypeCode.Double; break; case Operations.UnicodeCast: // TODO case Operations.StringCast: if ((returned_typecode = expr.Emit(codeGenerator)) != PhpTypeCode.String) { codeGenerator.EmitBoxing(returned_typecode); //codeGenerator.EmitLoadClassContext(); il.Emit(OpCodes.Call, Methods.Convert.ObjectToString); returned_typecode = PhpTypeCode.String; } break; case Operations.BinaryCast: if ((returned_typecode = expr.Emit(codeGenerator)) != PhpTypeCode.PhpBytes) { codeGenerator.EmitBoxing(returned_typecode); //codeGenerator.EmitLoadClassContext(); il.Emit(OpCodes.Call, Methods.Convert.ObjectToPhpBytes); returned_typecode = PhpTypeCode.PhpBytes; } break; case Operations.ArrayCast: //Template: "(array)x" Convert.ObjectToArray(x) o_typecode = expr.Emit(codeGenerator); if (o_typecode != PhpTypeCode.PhpArray) { codeGenerator.EmitBoxing(o_typecode); il.Emit(OpCodes.Call, Methods.Convert.ObjectToPhpArray); } returned_typecode = PhpTypeCode.PhpArray; break; case Operations.UnsetCast: // Template: "(unset)x" null il.Emit(OpCodes.Ldnull); returned_typecode = PhpTypeCode.Object; break; default: Debug.Assert(false, "illegal type of operation!"); returned_typecode = PhpTypeCode.Void; break; } switch (access) { case AccessType.Read: // do nothing break; case AccessType.None: // pop operation's result value from stack if (returned_typecode != PhpTypeCode.Void) il.Emit(OpCodes.Pop); return PhpTypeCode.Void; } return returned_typecode; }
internal override void EmitUnset(CodeGenerator codeGenerator) { //Template: "unset(x)" x = null Debug.Assert(access == AccessType.Read); // Cases 1, 4, 5, 6, 9 never reached Debug.Assert(codeGenerator.ChainBuilder.IsMember == false); // Case 3 never reached Debug.Assert(codeGenerator.ChainBuilder.IsArrayItem == false); codeGenerator.ChainBuilder.QuietRead = true; // 2, 7, 8 if (this.isMemberOf != null) { // 2: $b->a // 8: b[]->a codeGenerator.ChainBuilder.Create(); codeGenerator.ChainBuilder.Begin(); codeGenerator.ChainBuilder.QuietRead = true; EmitUnsetField(codeGenerator); codeGenerator.ChainBuilder.End(); return; } // 7: $a // Check if the variable is auto-global ILEmitter il = codeGenerator.IL; if (codeGenerator.VariableIsAutoGlobal(varName)) { codeGenerator.EmitAutoGlobalStorePrepare(varName); il.Emit(OpCodes.Ldnull); codeGenerator.EmitAutoGlobalStoreAssign(); return; } // Unset this variable if (codeGenerator.OptimizedLocals) { // Template: // unset(x) x = null // unset(p) p.value = null <- this case isn't valid. When p is reference just create a new PhpReference VariablesTable.Entry entry = codeGenerator.CurrentVariablesTable[varName]; if (entry.IsPhpReference) { il.Emit(OpCodes.Newobj, Constructors.PhpReference_Void); entry.Variable.EmitStore(il); } else { il.Emit(OpCodes.Ldnull); entry.Variable.EmitStore(il); } } else { // CALL Operators.UnsetVariable(<script context>, <local variable table>, <variable name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); il.Emit(OpCodes.Call, Methods.Operators.UnsetVariable); } }
/// <summary> /// Emits IL instructions that load the variable onto the evaluation stack. /// </summary> /// <param name="codeGenerator"></param> /// <remarks><B>$this</B> cannot be accessed indirectly.</remarks> internal override PhpTypeCode EmitLoad(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; if (codeGenerator.OptimizedLocals) { // Switch over all local variables and dereference those being of type PhpReference EmitSwitch(codeGenerator, new SwitchMethod(LoadLocal)); } else { // LOAD Operators.GetVariable[Unchecked](<script context>, <local variables table>, <variable name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); if (codeGenerator.ChainBuilder.QuietRead) il.Emit(OpCodes.Call, Methods.Operators.GetVariableUnchecked); else il.Emit(OpCodes.Call, Methods.Operators.GetVariable); } return PhpTypeCode.Object; }
/// <summary> /// Emit load of variable named <paramref name="varName"/>. /// </summary> internal static PhpTypeCode EmitLoad(CodeGenerator codeGenerator, VariableName varName) { ILEmitter il = codeGenerator.IL; // Check if the variable is auto-global if (codeGenerator.VariableIsAutoGlobal(varName)) { codeGenerator.EmitAutoGlobalLoad(varName); return PhpTypeCode.Object; } // Variable is local if (codeGenerator.OptimizedLocals) { // Template: // ldloc loc // ***** // If the specidied variable is of type PhpReference // ldfld PhpReference.value // ***** VariablesTable.Entry entry = codeGenerator.CurrentVariablesTable[varName]; entry.Variable.EmitLoad(il); if (entry.IsPhpReference) il.Emit(OpCodes.Ldfld, Fields.PhpReference_Value); return PhpTypeCode.Object; } // LOAD Operators.GetVariable[Unchecked](<script context>, <local variable table>, <name>); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Emit(OpCodes.Ldstr, varName.Value); if (codeGenerator.ChainBuilder.QuietRead) il.Emit(OpCodes.Call, Methods.Operators.GetVariableUnchecked); else il.Emit(OpCodes.Call, Methods.Operators.GetVariable); return PhpTypeCode.Object; }
internal override void EmitStoreRefPrepare(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; if (codeGenerator.OptimizedLocals) { // Switch over all variables // /*copypaste bug*/EmitSwitch(codeGenerator, new SwitchMethod(StoreLocalPrepare)); } else { // Template: // void Operators.SetVariable(table, "x", PhpVariable.Copy(Operators.getValue(table, "x"), CopyReason.Assigned)); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); EmitName(codeGenerator); // now load value the call Operators.SetVariable in EmitVariableStoreAssignFromTable } }
/// <summary> /// Emit reference load of variable named <paramref name="varName"/>. /// </summary> internal static void EmitLoadRef(CodeGenerator/*!*/ codeGenerator, VariableName varName) { ILEmitter il = codeGenerator.IL; // Check if the variable is auto-global if (codeGenerator.VariableIsAutoGlobal(varName)) { codeGenerator.EmitAutoGlobalLoadRef(varName); return; } if (codeGenerator.OptimizedLocals) { // Template: for DirectVarUse // "LOAD ref $x;" // // ldloc loc // Local variable should be of type PhpReference VariablesTable.Entry entry = codeGenerator.CurrentVariablesTable[varName]; entry.Variable.EmitLoad(il); } else { // Template: // PhpReference Operators.GetVariableRef(IDictionary table, string name) codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Emit(OpCodes.Ldstr, varName.Value); il.Emit(OpCodes.Call, Methods.Operators.GetVariableRef); } }
/// <summary> /// Loads a specified reference local variable. /// </summary> internal void LoadLocalRef(CodeGenerator codeGenerator, VariablesTable.Entry variable, LocalBuilder variableName) { ILEmitter il = codeGenerator.IL; Debug.Assert(variable == null ^ variableName == null); if (variable != null) { Debug.Assert(variable.IsPhpReference); variable.Variable.EmitLoad(il); } else { codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Ldloc(variableName); il.Emit(OpCodes.Call, Methods.Operators.GetVariableRef); } }
internal void Emit(CodeGenerator codeGenerator) { ILEmitter il = codeGenerator.IL; string id = codeGenerator.GetLocationId(); if (id == null) { // we are in global code -> just assign the iniVal to the variable variable.Emit(codeGenerator); if (initializer != null) { codeGenerator.EmitBoxing(initializer.Emit(codeGenerator)); il.Emit(OpCodes.Newobj, Constructors.PhpReference_Object); } else il.Emit(OpCodes.Newobj, Constructors.PhpReference_Void); variable.EmitAssign(codeGenerator); } else { // (J): cache the integer index of static local variable to access its value fast from within the array // unique static local variable string ID id = String.Format("{0}${1}${2}${3}", id, variable.VarName, position.FirstLine, position.FirstColumn); // create static field for static local index: private static int <id>; var type = codeGenerator.IL.TypeBuilder; Debug.Assert(type != null, "The method does not have declaring type! (global code in pure mode?)"); var field_id = type.DefineField(id, Types.Int[0], System.Reflection.FieldAttributes.Private | System.Reflection.FieldAttributes.Static); // we are in a function or method -> try to retrieve the local value from ScriptContext variable.Emit(codeGenerator); // <context>.GetStaticLocal( <field> ) codeGenerator.EmitLoadScriptContext(); // <context> il.Emit(OpCodes.Ldsfld, field_id); // <field> il.Emit(OpCodes.Callvirt, Methods.ScriptContext.GetStaticLocal); // GetStaticLocal il.Emit(OpCodes.Dup); // ?? <context>.AddStaticLocal( <field> != 0 ? <field> : ( <field> = ScriptContext.GetStaticLocalId(<id>) ), <initializer> ) if (true) { // if (GetStaticLocal(<field>) == null) Label local_initialized = il.DefineLabel(); il.Emit(OpCodes.Brtrue/*not .S, initializer can emit really long code*/, local_initialized); il.Emit(OpCodes.Pop); // <field> != 0 ? <field> : ( <field> = ScriptContext.GetStaticLocalId(<id>) ) il.Emit(OpCodes.Ldsfld, field_id); // <field> if (true) { // if (<field> == 0) Label id_initialized = il.DefineLabel(); il.Emit(OpCodes.Brtrue_S, id_initialized); // <field> = GetStaticLocalId( <id> ) il.Emit(OpCodes.Ldstr, id); il.Emit(OpCodes.Call, Methods.ScriptContext.GetStaticLocalId); il.Emit(OpCodes.Stsfld, field_id); il.MarkLabel(id_initialized); } // <context>.AddStaticLocal(<field>,<initialize>) codeGenerator.EmitLoadScriptContext(); // <context> il.Emit(OpCodes.Ldsfld, field_id); // <field> if (initializer != null) codeGenerator.EmitBoxing(initializer.Emit(codeGenerator)); // <initializer> else il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Callvirt, Methods.ScriptContext.AddStaticLocal); // AddStaticLocal // il.MarkLabel(local_initialized); } // (J) Following code used Dictionary. It was replaced by the code above. /* codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Ldstr, id); il.Emit(OpCodes.Call, Methods.ScriptContext.GetStaticLocal); Label reference_gotten = codeGenerator.IL.DefineLabel(); il.Emit(OpCodes.Dup); il.Emit(OpCodes.Brtrue, reference_gotten); il.Emit(OpCodes.Pop); // this is the first time execution reach the statement for current request -> initialize the local codeGenerator.EmitLoadScriptContext(); il.Emit(OpCodes.Ldstr, id); if (initializer != null) codeGenerator.EmitBoxing(initializer.Emit(codeGenerator)); else il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Call, Methods.ScriptContext.AddStaticLocal); // assign the resulting PhpReference into the variable il.MarkLabel(reference_gotten, true); */ variable.EmitAssign(codeGenerator); } }
/// <summary> /// Stores a reference on the top of the stack to a specified variable. /// </summary> internal void StoreLocalRefAssign(CodeGenerator codeGenerator, VariablesTable.Entry variable, LocalBuilder variableName) { ILEmitter il = codeGenerator.IL; Debug.Assert(variable == null ^ variableName == null); if (variable != null) { Debug.Assert(variable.IsPhpReference); variable.Variable.EmitStore(il); } else { // temp = STACK LocalBuilder temp = il.GetTemporaryLocal(Types.PhpReference[0], true); il.Stloc(temp); // CALL Operators.SetVariableRef(<local variables table>,<name>,temp); codeGenerator.EmitLoadScriptContext(); codeGenerator.EmitLoadRTVariablesTable(); il.Ldloc(variableName); il.Ldloc(temp); il.Emit(OpCodes.Call, Methods.Operators.SetVariableRef); } }
/// <include file='Doc/Nodes.xml' path='doc/method[@name="Emit"]/*'/> internal override PhpTypeCode Emit(CodeGenerator/*!*/ codeGenerator) { Statistics.AST.AddNode("LambdaFunctionExpr"); var typeBuilder = codeGenerator.IL.TypeBuilder; // define argless and argfull this.function.DefineBuilders(typeBuilder); // codeGenerator.MarkSequencePoint(position.FirstLine, position.FirstColumn, position.LastLine, position.LastColumn + 2); if (!codeGenerator.EnterFunctionDeclaration(function)) throw new Exception("EnterFunctionDeclaration() failed!"); codeGenerator.EmitArgfullOverloadBody(function, body, entireDeclarationPosition, declarationBodyPosition); codeGenerator.LeaveFunctionDeclaration(); // new Closure( <context>, new RoutineDelegate(null,function.ArgLess), <parameters>, <static> ) codeGenerator.EmitLoadScriptContext(); var/*!*/il = codeGenerator.IL; il.Emit(OpCodes.Ldnull); il.Emit(OpCodes.Ldftn, function.ArgLessInfo); il.Emit(OpCodes.Newobj, Constructors.RoutineDelegate); int userParamsCount = (useParams != null) ? useParams.Count : 0; if (signature.FormalParams != null && signature.FormalParams.Count > userParamsCount) { // array = new PhpArray(<int_count>, <string_count>); il.Emit(OpCodes.Ldc_I4, 0); il.Emit(OpCodes.Ldc_I4, signature.FormalParams.Count); il.Emit(OpCodes.Newobj, Constructors.PhpArray.Int32_Int32); for (int i = userParamsCount; i < signature.FormalParams.Count; i++) { var p = signature.FormalParams[i]; // CALL array.SetArrayItem("&$name", "<required>" | "<optional>"); il.Emit(OpCodes.Dup); // PhpArray string keyValue = string.Format("{0}${1}", p.PassedByRef ? "&" : null, p.Name.Value); il.Emit(OpCodes.Ldstr, keyValue); il.Emit(OpCodes.Ldstr, (p.InitValue != null) ? "<optional>" : "<required>"); il.LdcI4(IntStringKey.StringKeyToArrayIndex(keyValue)); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemExact_String); } } else { il.Emit(OpCodes.Ldnull); } if (userParamsCount > 0) { // array = new PhpArray(<int_count>, <string_count>); il.Emit(OpCodes.Ldc_I4, 0); il.Emit(OpCodes.Ldc_I4, useParams.Count); il.Emit(OpCodes.Newobj, Constructors.PhpArray.Int32_Int32); foreach (var p in useParams) { // <stack>.SetArrayItem{Ref} il.Emit(OpCodes.Dup); // PhpArray string variableName = p.Name.Value; il.Emit(OpCodes.Ldstr, variableName); if (p.PassedByRef) { DirectVarUse.EmitLoadRef(codeGenerator, p.Name); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemRef_String); } else { // LOAD PhpVariable.Copy( <name>, Assigned ) DirectVarUse.EmitLoad(codeGenerator, p.Name); il.LdcI4((int)CopyReason.Assigned); il.Emit(OpCodes.Call, Methods.PhpVariable.Copy); // .SetArrayItemExact( <stack>, <stack>, <hashcode> ) il.LdcI4(IntStringKey.StringKeyToArrayIndex(variableName)); il.Emit(OpCodes.Call, Methods.PhpArray.SetArrayItemExact_String); } } } else { il.Emit(OpCodes.Ldnull); } il.Emit(OpCodes.Newobj, typeof(PHP.Library.SPL.Closure).GetConstructor(new Type[] { typeof(ScriptContext), typeof(RoutineDelegate), typeof(PhpArray), typeof(PhpArray) })); return PhpTypeCode.Object; }