fn store_opcode_args(&mut self, args: &[FTerm]) {
    for a in args {
      match *a {
        // Ext list is special so we convert it and its contents to lterm
        FTerm::LoadTimeExtlist(ref jtab) => {
          // Push a header word with length
          let heap_jtab = allocate_tuple(&mut self.lit_heap, jtab.len()).unwrap();
          self.code.push(heap_jtab.make_term().raw());

          // Each value convert to LTerm and also push forming a tuple
          for (index, t) in jtab.iter().enumerate() {
            let new_t = if let FTerm::LoadTimeLabel(f) = *t {
              // Try to resolve labels and convert now, or postpone
              let ploc = PatchLocation::PatchJtabElement(heap_jtab.make_term(), index);
              self.maybe_convert_label(LabelId(f), ploc)
            } else {
              t.to_lterm(&mut self.lit_heap).raw()
            };

            unsafe { heap_jtab.set_raw_word_base0(index, new_t) }
          }
        }

        // Label value is special, we want to remember where it was
        // to convert it to an offset
        FTerm::LoadTimeLabel(f) => {
          let ploc = PatchLocation::PatchCodeOffset(self.code.len());
          let new_t = self.maybe_convert_label(LabelId(f),
                                               ploc);
          self.code.push(new_t)
        }

        // Load-time literals are already loaded on `self.lit_heap`
        FTerm::LoadTimeLit(lit_index) => {
          self.code.push(self.lit_tab[lit_index].raw())
        }

          // Otherwise convert via a simple method
        _ => self.code.push(a.to_lterm(&mut self.lit_heap).raw()),
      }
    } // for a in args
  }
/// Given arity amount of `args` from another opcode, process them and store
/// into the `self.code` array. `LoadTimeExtList` get special treatment as a
/// container of terms. `LoadTimeLabel` get special treatment as we try to
/// resolve them into an offset.
Given arity amount of `args` from another opcode, process them and store
into the `self.code` array. `LoadTimeExtList` get special treatment as a
container of terms. `LoadTimeLabel` get special treatment as we try to
resolve them into an offset.
Given arity amount of ` args ` from another opcode process them and store into the ` self . code ` array . ` LoadTimeExtList ` get special treatment as a container of terms . ` LoadTimeLabel ` get special treatment as we try to resolve them into an offset .
fn store_opcode_args(&mut self, args: &[FTerm]) {
    for a in args {
      match *a {
        // Ext list is special so we convert it and its contents to lterm
        FTerm::LoadTimeExtlist(ref jtab) => {
          // Push a header word with length
          let heap_jtab = allocate_tuple(&mut self.lit_heap, jtab.len()).unwrap();
          self.code.push(heap_jtab.make_term().raw());
          // Each value convert to LTerm and also push forming a tuple
          for (index, t) in jtab.iter().enumerate() {
            let new_t = if let FTerm::LoadTimeLabel(f) = *t {
              // Try to resolve labels and convert now, or postpone
              let ploc = PatchLocation::PatchJtabElement(heap_jtab.make_term(), index);
              self.maybe_convert_label(LabelId(f), ploc)
            } else {
              t.to_lterm(&mut self.lit_heap).raw()
            };
            unsafe { heap_jtab.set_raw_word_base0(index, new_t) }
          }
        }
        // Label value is special, we want to remember where it was
        // to convert it to an offset
        FTerm::LoadTimeLabel(f) => {
          let ploc = PatchLocation::PatchCodeOffset(self.code.len());
          let new_t = self.maybe_convert_label(LabelId(f),
                                               ploc);
          self.code.push(new_t)
        }
        // Load-time literals are already loaded on `self.lit_heap`
        FTerm::LoadTimeLit(lit_index) => {
          self.code.push(self.lit_tab[lit_index].raw())
        }
          // Otherwise convert via a simple method
        _ => self.code.push(a.to_lterm(&mut self.lit_heap).raw()),
      }
    } // for a in args
  }
fn store_opcode_args ( & mut self , args : & [ FTerm ] ) { for a in args { match * a { // Ext list is special so we convert it and its contents to lterm FTerm :: LoadTimeExtlist ( ref jtab ) => { // Push a header word with length let heap_jtab = allocate_tuple ( & mut self . lit_heap , jtab . len ( ) ) . unwrap ( ) ; self . code . push ( heap_jtab . make_term ( ) . raw ( ) ) ; // Each value convert to LTerm and also push forming a tuple for ( index , t ) in jtab . iter ( ) . enumerate ( ) { let new_t = if let FTerm :: LoadTimeLabel ( f ) = * t { // Try to resolve labels and convert now, or postpone let ploc = PatchLocation :: PatchJtabElement ( heap_jtab . make_term ( ) , index ) ; self . maybe_convert_label ( LabelId ( f ) , ploc ) } else { t . to_lterm ( & mut self . lit_heap ) . raw ( ) } ; unsafe { heap_jtab . set_raw_word_base0 ( index , new_t ) } } } // Label value is special, we want to remember where it was // to convert it to an offset FTerm :: LoadTimeLabel ( f ) => { let ploc = PatchLocation :: PatchCodeOffset ( self . code . len ( ) ) ; let new_t = self . maybe_convert_label ( LabelId ( f ) , ploc ) ; self . code . push ( new_t ) } // Load-time literals are already loaded on `self.lit_heap` FTerm :: LoadTimeLit ( lit_index ) => { self . code . push ( self . lit_tab [ lit_index ] . raw ( ) ) } // Otherwise convert via a simple method _ => self . code . push ( a . to_lterm ( & mut self . lit_heap ) . raw ( ) ) , } } // for a in args }
Given arity amount of `args` from another opcode, process them and store
into the `self.code` array.
Given arity amount of ` args ` from another opcode process them and store into the ` self . code ` array .
&mut self
args
&[FTerm]